connected-spaces-platform.web 4.29.1 → 4.30.0

package/connectedspacesplatform.ts

@@ -366,6 +366,14 @@ function csp_multiplayer_EPermissionChangeTypeFactory(
 ProxyClassFactories["csp_multiplayer_EPermissionChangeType"] =
   csp_multiplayer_EPermissionChangeTypeFactory;
 
+function csp_multiplayer_ESequenceUpdateTypeFactory(
+  nativePointer: NativePointer,
+): Multiplayer.ESequenceUpdateType {
+  return nativePointer.pointer as Multiplayer.ESequenceUpdateType;
+}
+ProxyClassFactories["csp_multiplayer_ESequenceUpdateType"] =
+  csp_multiplayer_ESequenceUpdateTypeFactory;
+
 function csp_multiplayer_ConnectionStateFactory(
   nativePointer: NativePointer,
 ): Multiplayer.ConnectionState {
@@ -597,14 +605,6 @@ function csp_multiplayer_GaussianSplatPropertyKeysFactory(
 ProxyClassFactories["csp_multiplayer_GaussianSplatPropertyKeys"] =
   csp_multiplayer_GaussianSplatPropertyKeysFactory;
 
-function csp_multiplayer_HotspotTypeFactory(
-  nativePointer: NativePointer,
-): Multiplayer.HotspotType {
-  return nativePointer.pointer as Multiplayer.HotspotType;
-}
-ProxyClassFactories["csp_multiplayer_HotspotType"] =
-  csp_multiplayer_HotspotTypeFactory;
-
 function csp_multiplayer_HotspotPropertyKeysFactory(
   nativePointer: NativePointer,
 ): Multiplayer.HotspotPropertyKeys {
@@ -1015,6 +1015,14 @@ function csp_multiplayer_UserPermissionsParamsFactory(
 ProxyClassFactories["csp_multiplayer_UserPermissionsParams"] =
   csp_multiplayer_UserPermissionsParamsFactory;
 
+function csp_multiplayer_SequenceChangedParamsFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Multiplayer.SequenceChangedParams(nativePointer);
+}
+ProxyClassFactories["csp_multiplayer_SequenceChangedParams"] =
+  csp_multiplayer_SequenceChangedParamsFactory;
+
 function csp_multiplayer_MultiplayerConnectionFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -1349,6 +1357,13 @@ function csp_systems_ScriptSystemFactory(
 ProxyClassFactories["csp_systems_ScriptSystem"] =
   csp_systems_ScriptSystemFactory;
 
+function csp_systems_SequenceFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.Sequence(nativePointer);
+}
+ProxyClassFactories["csp_systems_Sequence"] = csp_systems_SequenceFactory;
+
 function csp_systems_SettingsCollectionFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -2033,6 +2048,30 @@ function csp_systems_QuotaSystemFactory(
 }
 ProxyClassFactories["csp_systems_QuotaSystem"] = csp_systems_QuotaSystemFactory;
 
+function csp_systems_SequenceResultFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.SequenceResult(nativePointer);
+}
+ProxyClassFactories["csp_systems_SequenceResult"] =
+  csp_systems_SequenceResultFactory;
+
+function csp_systems_SequencesResultFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.SequencesResult(nativePointer);
+}
+ProxyClassFactories["csp_systems_SequencesResult"] =
+  csp_systems_SequencesResultFactory;
+
+function csp_systems_SequenceSystemFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.SequenceSystem(nativePointer);
+}
+ProxyClassFactories["csp_systems_SequenceSystem"] =
+  csp_systems_SequenceSystemFactory;
+
 function csp_systems_SettingsCollectionResultFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -2569,6 +2608,18 @@ function csp_common_Array_csp_systems_TierFeaturesFactory(
 ProxyClassFactories["csp_common_Array_csp_systems_TierFeatures"] =
   csp_common_Array_csp_systems_TierFeaturesFactory;
 
+function csp_common_Array_csp_systems_SequenceFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Common.Array<Systems.Sequence>(
+    nativePointer,
+    csp_systems_SequenceFactory,
+    "csp_systems_Sequence",
+  );
+}
+ProxyClassFactories["csp_common_Array_csp_systems_Sequence"] =
+  csp_common_Array_csp_systems_SequenceFactory;
+
 function csp_common_Array_csp_systems_SiteFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -2905,6 +2956,14 @@ export namespace Multiplayer {
   }
 }
 
+export namespace Multiplayer {
+  export enum ESequenceUpdateType {
+    Create,
+    Update,
+    Delete,
+  }
+}
+
 export namespace Multiplayer {
   /**
    * @description Enum used to specify the current state of the multiplayer connection.
@@ -3337,13 +3396,6 @@ export namespace Multiplayer {
   }
 }
 
-export namespace Multiplayer {
-  export enum HotspotType {
-    TeleportHotspot = 0,
-    SpawnHotspot,
-  }
-}
-
 export namespace Multiplayer {
   /**
    * @description Enumerates the list of properties that can be replicated for an Hotspot space component.
@@ -3352,7 +3404,8 @@ export namespace Multiplayer {
     Position,
     Rotation,
     Name,
-    HotspotType,
+    IsTeleportPoint,
+    IsSpawnPoint,
     IsVisible,
     IsARVisible,
     Num,
@@ -21657,6 +21710,104 @@ export namespace Multiplayer {
   }
 }
 
+export namespace Multiplayer {
+  export class SequenceChangedParams
+    extends NativeClassWrapper
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static create(): SequenceChangedParams {
+      var _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_multiplayer_SequenceChangedParams_Ctor",
+        "void",
+        ["number"],
+        [_ptr],
+      );
+      var _nPtr = getNativePointer(_ptr);
+
+      return new SequenceChangedParams(_nPtr);
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_multiplayer_SequenceChangedParams_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+
+    get updateType(): Multiplayer.ESequenceUpdateType {
+      let _result = Module.ccall(
+        "csp_multiplayer_SequenceChangedParams__Get_UpdateType",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set updateType(value: Multiplayer.ESequenceUpdateType) {
+      Module.ccall(
+        "csp_multiplayer_SequenceChangedParams__Set_UpdateType",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    get key(): string {
+      let _result = Module.ccall(
+        "csp_multiplayer_SequenceChangedParams__Get_Key",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set key(value: string) {
+      Module.ccall(
+        "csp_multiplayer_SequenceChangedParams__Set_Key",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get newKey(): string {
+      let _result = Module.ccall(
+        "csp_multiplayer_SequenceChangedParams__Get_NewKey",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set newKey(value: string) {
+      Module.ccall(
+        "csp_multiplayer_SequenceChangedParams__Set_NewKey",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+  }
+}
+
 export namespace Multiplayer {
   /**
 @ingroup Multiplayer
@@ -21904,6 +22055,31 @@ export namespace Multiplayer {
       );
     }
 
+    /**
+     * @description Sets a callback for a sequence changed event.
+     * @param callback - Callback to receive data for the sequence that has been changed.
+     */
+    setSequenceChangedCallback(
+      callback: (arg1: Multiplayer.SequenceChangedParams) => void,
+    ) {
+      var _callback = (_stateObject__: number, arg1) => {
+        var _arg1 = new Multiplayer.SequenceChangedParams(
+          getNativePointer(arg1),
+        );
+
+        callback(_arg1);
+      };
+
+      var _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_multiplayer_MultiplayerConnection_SetSequenceChangedCallback_void_SequenceChangedCallbackHandler",
+        "void",
+        ["number", "number", "number"],
+        [this.pointer, _callbackPtr, 0],
+      );
+    }
+
     /**
      * @description Registers a callback to listen for the named event.
      * @param eventName - The identifying name for the event to listen for.
@@ -25521,6 +25697,26 @@ export namespace Systems {
       return _nPtr;
     }
 
+    /**
+     * @description Retrieves the Sequence system.
+     * @return Pointer to the sequence system class
+     */
+
+    getSequenceSystem(): Systems.SequenceSystem {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_SystemsManager_GetSequenceSystem_SequenceSystemP",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Systems.SequenceSystem(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
     getSpaceEntitySystem(): Multiplayer.SpaceEntitySystem {
       var _ret = Module._malloc(8);
 
@@ -29930,6 +30126,122 @@ export namespace Systems {
   }
 }
 
+export namespace Systems {
+  /**
+@ingroup Sequence System
+ * @description A basic class abstraction for a sequence, including key, and reference variables, and items.  
+ */
+  export class Sequence extends NativeClassWrapper implements INativeResource {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static create(): Sequence {
+      var _ptr = Module._malloc(8);
+      Module.ccall("csp_systems_Sequence_Ctor", "void", ["number"], [_ptr]);
+      var _nPtr = getNativePointer(_ptr);
+
+      return new Sequence(_nPtr);
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_Sequence_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+
+    get key(): string {
+      let _result = Module.ccall(
+        "csp_systems_Sequence__Get_Key",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set key(value: string) {
+      Module.ccall(
+        "csp_systems_Sequence__Set_Key",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get referenceType(): string {
+      let _result = Module.ccall(
+        "csp_systems_Sequence__Get_ReferenceType",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set referenceType(value: string) {
+      Module.ccall(
+        "csp_systems_Sequence__Set_ReferenceType",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get referenceId(): string {
+      let _result = Module.ccall(
+        "csp_systems_Sequence__Get_ReferenceId",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set referenceId(value: string) {
+      Module.ccall(
+        "csp_systems_Sequence__Set_ReferenceId",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get items(): Common.Array<string> {
+      const _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_systems_Sequence__Get_Items",
+        "void",
+        ["number", "number"],
+        [_ptr, this.pointer],
+      );
+
+      const _nPtr = getNativePointer(_ptr);
+      return new Common.Array<string>(_nPtr, StringFactory, "String");
+    }
+
+    set items(value: Common.Array<string>) {
+      Module.ccall(
+        "csp_systems_Sequence__Set_Items",
+        "void",
+        ["number", "number"],
+        [this.pointer, value.pointer],
+      );
+    }
+  }
+}
+
 export namespace Systems {
   /**
 @ingroup Settings System
@@ -37893,13 +38205,13 @@ export namespace Multiplayer {
     }
 
     /**
-     * @description Gets the HotspotType of this Hotspot.
+     * @description Gets the IsTeleportPoint of this Hotspot.
      */
 
-    getHotspotType(): Multiplayer.HotspotType {
+    getIsTeleportPoint(): boolean {
       let _result = Module.ccall(
-        "csp_multiplayer_HotspotSpaceComponent_GetHotspotTypeC_HotspotType",
-        "number",
+        "csp_multiplayer_HotspotSpaceComponent_GetIsTeleportPointC_bool",
+        "boolean",
         ["number"],
         [this.pointer],
       );
@@ -37908,15 +38220,44 @@ export namespace Multiplayer {
     }
 
     /**
-     * @description Sets the HotspotType of this Hotspot.
-     * @param value - The Type of the Hotspot.
+     * @description Sets this Hotspot to be a teleport point.
+     * @param inValue - The teleport point state flag value.
      */
 
-    setHotspotType(value: Multiplayer.HotspotType): void {
+    setIsTeleportPoint(value: boolean): void {
       Module.ccall(
-        "csp_multiplayer_HotspotSpaceComponent_SetHotspotType_void_HotspotType",
+        "csp_multiplayer_HotspotSpaceComponent_SetIsTeleportPoint_void_bool",
         "void",
-        ["number", "number"],
+        ["number", "boolean"],
+        [this.pointer, value],
+      );
+    }
+
+    /**
+     * @description Gets the IsSpawnPoint of this Hotspot.
+     */
+
+    getIsSpawnPoint(): boolean {
+      let _result = Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_GetIsSpawnPointC_bool",
+        "boolean",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+     * @description Sets this Hotspot to be a spawn point.
+     * @param inValue - The spawn point state flag value.
+     */
+
+    setIsSpawnPoint(value: boolean): void {
+      Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_SetIsSpawnPoint_void_bool",
+        "void",
+        ["number", "boolean"],
         [this.pointer, value],
       );
     }
@@ -47174,6 +47515,339 @@ export namespace Systems {
   }
 }
 
+export namespace Systems {
+  /**
+@ingroup Sequence System
+ * @description Result structure for a sequence result  
+ */
+  export class SequenceResult
+    extends Systems.ResultBase
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromResultBase(
+      baseInstance: Systems.ResultBase,
+    ): Systems.SequenceResult {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.SequenceResult(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    getSequence(): Systems.Sequence {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_SequenceResult_GetSequenceC_SequenceRC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Systems.Sequence(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_SequenceResult_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
+export namespace Systems {
+  /**
+@ingroup Sequence System
+ * @description Data class used to contain information when attempting to get an array of sequences.  
+ */
+  export class SequencesResult
+    extends Systems.ResultBase
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromResultBase(
+      baseInstance: Systems.ResultBase,
+    ): Systems.SequencesResult {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.SequencesResult(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    getSequences(): Common.Array<Systems.Sequence> {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_SequencesResult_GetSequencesC_ArrayRC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.Array<Systems.Sequence>(
+        getNativePointer(_ret),
+        csp_systems_SequenceFactory,
+        "csp_systems_Sequence",
+      );
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_SequencesResult_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
+export namespace Systems {
+  /**
+@ingroup Sequence System
+ * @description Public facing system that allows the management of groupings of items in a space.  
+ */
+  export class SequenceSystem extends Systems.SystemBase {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromSystemBase(
+      baseInstance: Systems.SystemBase,
+    ): Systems.SequenceSystem {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.SequenceSystem(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    /**
+     * @description Creates a new sequence. If a sequence already exists with this key, it will overwrite the current one. This call will fail if the user
+     * isn't a creator of the space.
+     * @param sequenceKey - The unique grouping name. The suggested convention is: Type:[Id]
+     * @param referenceType - The type of reference (GroupId, SpaceId etc.)
+     * @param referenceId - The id of the reference
+     * @param items - An ordered array of members
+     * @param callback - Callback to call when a response is received
+     */
+
+    createSequence(
+      sequenceKey: string,
+      referenceType: string,
+      referenceId: string,
+      items: Common.Array<string>,
+      callback: (result: Systems.SequenceResult) => void,
+    ): void {
+      var _callback = (_stateObject__: number, result) => {
+        var _result = new Systems.SequenceResult(getNativePointer(result));
+        callback(_result);
+      };
+
+      var callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_SequenceSystem_CreateSequence_void_StringRC_StringRC_StringRC_ArrayRC_SequenceResultCallback",
+        "void",
+        ["number", "string", "string", "string", "number", "number"],
+        [
+          this.pointer,
+          sequenceKey,
+          referenceType,
+          referenceId,
+          items.pointer,
+          callbackPtr,
+        ],
+      );
+    }
+
+    /**
+     * @description Updates an existing sequence. This call will fail if the user isn't a creator of the space.
+     * @param sequenceKey - The unique grouping name. The suggested convention is: Type:[Id]
+     * @param referenceType - The type of reference (GroupId, SpaceId etc.)
+     * @param referenceId - The id of the reference
+     * @param items - An ordered array of members
+     * @param callback - Callback to call when a response is received
+     */
+
+    updateSequence(
+      sequenceKey: string,
+      referenceType: string,
+      referenceId: string,
+      items: Common.Array<string>,
+      callback: (result: Systems.SequenceResult) => void,
+    ): void {
+      var _callback = (_stateObject__: number, result) => {
+        var _result = new Systems.SequenceResult(getNativePointer(result));
+        callback(_result);
+      };
+
+      var callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_SequenceSystem_UpdateSequence_void_StringRC_StringRC_StringRC_ArrayRC_SequenceResultCallback",
+        "void",
+        ["number", "string", "string", "string", "number", "number"],
+        [
+          this.pointer,
+          sequenceKey,
+          referenceType,
+          referenceId,
+          items.pointer,
+          callbackPtr,
+        ],
+      );
+    }
+
+    /**
+     * @description Renames a given sequence. This call will fail if the user isn't a creator of the space.
+     * @param oldSequenceKey - The current sequence key name
+     * @param newSequenceKey - The new sequence key name
+     * @param callback - Callback to call when a response is received
+     */
+
+    renameSequence(
+      oldSequenceKey: string,
+      newSequenceKey: string,
+      callback: (result: Systems.SequenceResult) => void,
+    ): void {
+      var _callback = (_stateObject__: number, result) => {
+        var _result = new Systems.SequenceResult(getNativePointer(result));
+        callback(_result);
+      };
+
+      var callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_SequenceSystem_RenameSequence_void_StringRC_StringRC_SequenceResultCallback",
+        "void",
+        ["number", "string", "string", "number"],
+        [this.pointer, oldSequenceKey, newSequenceKey, callbackPtr],
+      );
+    }
+
+    /**
+     * @description Finds sequences based on the given criteria
+     * @param sequenceKeys - An array of sequence keys to search for
+     * @param sequenceKeys - An optional regex string for searching keys
+     * @param referenceType - The type of reference (GroupId, SpaceId etc.). Must be used with ReferenceIds
+     * @param referenceIds - The ids of the reference. Must be used with ReferenceType
+     * @param callback - Callback to call when a response is received
+     */
+
+    getSequencesByCriteria(
+      sequenceKeys: Common.Array<string>,
+      keyRegex: string,
+      referenceType: string,
+      referenceIds: Common.Array<string>,
+      callback: (result: Systems.SequencesResult) => void,
+    ): void {
+      var _callback = (_stateObject__: number, result) => {
+        var _result = new Systems.SequencesResult(getNativePointer(result));
+        callback(_result);
+      };
+
+      var callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_SequenceSystem_GetSequencesByCriteria_void_ArrayRC_StringRC_StringRC_ArrayRC_SequencesResultCallback",
+        "void",
+        ["number", "number", "string", "string", "number", "number"],
+        [
+          this.pointer,
+          sequenceKeys.pointer,
+          keyRegex,
+          referenceType,
+          referenceIds.pointer,
+          callbackPtr,
+        ],
+      );
+    }
+
+    /**
+     * @description Gets a sequence by it's key
+     * @param sequenceKey - The unique grouping name
+     * @param callback - Callback to call when a response is received
+     */
+
+    getSequence(
+      sequenceKey: string,
+      callback: (result: Systems.SequenceResult) => void,
+    ): void {
+      var _callback = (_stateObject__: number, result) => {
+        var _result = new Systems.SequenceResult(getNativePointer(result));
+        callback(_result);
+      };
+
+      var callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_SequenceSystem_GetSequence_void_StringRC_SequenceResultCallback",
+        "void",
+        ["number", "string", "number"],
+        [this.pointer, sequenceKey, callbackPtr],
+      );
+    }
+
+    /**
+     * @description Deletes the given sequences. This call will fail if the user isn't a creator of the space
+     * @param sequenceKeys - An array of sequence keys to delete
+     * @param callback - Callback to call when a response is received
+     */
+
+    deleteSequences(
+      sequenceKeys: Common.Array<string>,
+      callback: (result: Systems.NullResult) => void,
+    ): void {
+      var _callback = (_stateObject__: number, result) => {
+        var _result = new Systems.NullResult(getNativePointer(result));
+        callback(_result);
+      };
+
+      var callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_SequenceSystem_DeleteSequences_void_ArrayRC_NullResultCallback",
+        "void",
+        ["number", "number", "number"],
+        [this.pointer, sequenceKeys.pointer, callbackPtr],
+      );
+    }
+  }
+}
+
 export namespace Systems {
   /**
 @ingroup Settings System
@@ -53639,6 +54313,24 @@ export namespace Common {
       return _inst;
     }
 
+    static ofcsp_systems_Sequence(): Array<Systems.Sequence> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Ctor_csp_systems_Sequence",
+        "void",
+        ["number"],
+        [_ret],
+      );
+      var _inst = new Array<Systems.Sequence>(
+        getNativePointer(_ret),
+        csp_systems_SequenceFactory,
+        "csp_systems_Sequence",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
     static ofcsp_systems_Site(): Array<Systems.Site> {
       var _ret = Module._malloc(8);
       Module.ccall(
@@ -54395,6 +55087,26 @@ export namespace Common {
       return _inst;
     }
 
+    static ofcsp_systems_Sequence_number(
+      size: number,
+    ): Array<Systems.Sequence> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Conv_size_tC_csp_systems_Sequence",
+        "void",
+        ["number", "number"],
+        [_ret, size],
+      );
+      var _inst = new Array<Systems.Sequence>(
+        getNativePointer(_ret),
+        csp_systems_SequenceFactory,
+        "csp_systems_Sequence",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
     static ofcsp_systems_Site_number(size: number): Array<Systems.Site> {
       var _ret = Module._malloc(8);
       Module.ccall(