connected-spaces-platform.web 6.10.0 → 6.12.0

package/connectedspacesplatform.ts

@@ -946,6 +946,14 @@ function csp_systems_TicketStatusFactory(
 ProxyClassFactories["csp_systems_TicketStatus"] =
   csp_systems_TicketStatusFactory;
 
+function csp_systems_PubSubModelTypeFactory(
+  nativePointer: NativePointer,
+): Systems.PubSubModelType {
+  return nativePointer.pointer as Systems.PubSubModelType;
+}
+ProxyClassFactories["csp_systems_PubSubModelType"] =
+  csp_systems_PubSubModelTypeFactory;
+
 function csp_systems_PeriodEnumFactory(
   nativePointer: NativePointer,
 ): Systems.PeriodEnum {
@@ -1529,6 +1537,20 @@ function csp_systems_MaintenanceInfoFactory(
 ProxyClassFactories["csp_systems_MaintenanceInfo"] =
   csp_systems_MaintenanceInfoFactory;
 
+function csp_systems_ScopeFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.Scope(nativePointer);
+}
+ProxyClassFactories["csp_systems_Scope"] = csp_systems_ScopeFactory;
+
+function csp_systems_ScopeLeaderFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.ScopeLeader(nativePointer);
+}
+ProxyClassFactories["csp_systems_ScopeLeader"] = csp_systems_ScopeLeaderFactory;
+
 function csp_systems_FeatureLimitInfoFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -2358,6 +2380,37 @@ function csp_systems_MaintenanceSystemFactory(
 ProxyClassFactories["csp_systems_MaintenanceSystem"] =
   csp_systems_MaintenanceSystemFactory;
 
+function csp_systems_MultiplayerSystemFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.MultiplayerSystem(nativePointer);
+}
+ProxyClassFactories["csp_systems_MultiplayerSystem"] =
+  csp_systems_MultiplayerSystemFactory;
+
+function csp_systems_ScopeResultFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.ScopeResult(nativePointer);
+}
+ProxyClassFactories["csp_systems_ScopeResult"] = csp_systems_ScopeResultFactory;
+
+function csp_systems_ScopesResultFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.ScopesResult(nativePointer);
+}
+ProxyClassFactories["csp_systems_ScopesResult"] =
+  csp_systems_ScopesResultFactory;
+
+function csp_systems_ScopeLeaderResultFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.ScopeLeaderResult(nativePointer);
+}
+ProxyClassFactories["csp_systems_ScopeLeaderResult"] =
+  csp_systems_ScopeLeaderResultFactory;
+
 function csp_systems_FeaturesLimitResultFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -3022,6 +3075,18 @@ function csp_common_Array_csp_systems_MaintenanceInfoFactory(
 ProxyClassFactories["csp_common_Array_csp_systems_MaintenanceInfo"] =
   csp_common_Array_csp_systems_MaintenanceInfoFactory;
 
+function csp_common_Array_csp_systems_ScopeFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Common.Array<Systems.Scope>(
+    nativePointer,
+    csp_systems_ScopeFactory,
+    "csp_systems_Scope",
+  );
+}
+ProxyClassFactories["csp_common_Array_csp_systems_Scope"] =
+  csp_common_Array_csp_systems_ScopeFactory;
+
 function csp_common_Array_csp_systems_FeatureLimitInfoFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -4559,6 +4624,7 @@ export namespace Systems {
     MATERIAL,
     ANNOTATION,
     ANNOTATION_THUMBNAIL,
+    TEXT,
   }
 }
 
@@ -4665,6 +4731,21 @@ export namespace Systems {
   }
 }
 
+export namespace Systems {
+  /**
+@ingroup Multiplayer System
+ * @description Enum representing the scopes pub/sub model type  
+ * Object: used in object scopes, each object is published to its own channel, and  
+ * client subscribes to the channels of only the objects they can see  
+ * Global: used in global scopes, all objects are published to a single channel,  
+ * client subscribes to the channel and can see everything in the channel/scope  
+ */
+  export enum PubSubModelType {
+    Object,
+    Global,
+  }
+}
+
 export namespace Systems {
   /**
 @ingroup Quota System
@@ -4687,9 +4768,9 @@ export namespace Systems {
     TotalUploadSizeInKilobytes,
     Agora,
     OpenAI,
+    GoogleGenAI,
     Shopify,
     TicketedSpace,
-    GoogleGenAI,
     Invalid,
   }
 }
@@ -5445,6 +5526,28 @@ export class EndpointURIs
       [this.pointer, value.pointer],
     );
   }
+
+  get multiplayerConnection(): ServiceDefinition {
+    const _ptr = Module._malloc(8);
+    Module.ccall(
+      "csp_EndpointURIs__Get_MultiplayerConnection",
+      "void",
+      ["number", "number"],
+      [_ptr, this.pointer],
+    );
+
+    const _nPtr = getNativePointer(_ptr);
+    return new ServiceDefinition(_nPtr);
+  }
+
+  set multiplayerConnection(value: ServiceDefinition) {
+    Module.ccall(
+      "csp_EndpointURIs__Set_MultiplayerConnection",
+      "void",
+      ["number", "number"],
+      [this.pointer, value.pointer],
+    );
+  }
 }
 
 /**
@@ -21420,12 +21523,12 @@ export namespace Common {
     /**
      * @description Gets mime type from a file path.
      * @param filePath - Const string&
-     * @return String&
+     * @return Const string&
      */
 
     getMimeType(filePath: string): string {
       let _result = Module.ccall(
-        "csp_common_MimeTypeHelper_GetMimeType_StringR_StringRC",
+        "csp_common_MimeTypeHelper_GetMimeType_StringRC_StringRC",
         "number",
         ["number", "string"],
         [this.pointer, filePath],
@@ -28183,6 +28286,21 @@ export namespace Systems {
       return _nPtr;
     }
 
+    getMultiplayerSystem(): Systems.MultiplayerSystem {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_SystemsManager_GetMultiplayerSystem_MultiplayerSystemP",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Systems.MultiplayerSystem(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
     getMultiplayerConnection(): Multiplayer.MultiplayerConnection {
       var _ret = Module._malloc(8);
 
@@ -32167,6 +32285,281 @@ export namespace Systems {
   }
 }
 
+export namespace Systems {
+  /**
+@ingroup Multiplayer System
+ * @description Data representation for a scope in a space.  
+ * Scopes represent different channels in a space which objects can exist in.  
+ * This allows csp/mcs to only reason about objects in specific scopes.  
+ */
+  export class Scope extends NativeClassWrapper implements INativeResource {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static create(): Scope {
+      var _ptr = Module._malloc(8);
+      Module.ccall("csp_systems_Scope_Ctor", "void", ["number"], [_ptr]);
+      var _nPtr = getNativePointer(_ptr);
+
+      return new Scope(_nPtr);
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_Scope_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+
+    get id(): string {
+      let _result = Module.ccall(
+        "csp_systems_Scope__Get_Id",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set id(value: string) {
+      Module.ccall(
+        "csp_systems_Scope__Set_Id",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get referenceId(): string {
+      let _result = Module.ccall(
+        "csp_systems_Scope__Get_ReferenceId",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set referenceId(value: string) {
+      Module.ccall(
+        "csp_systems_Scope__Set_ReferenceId",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get referenceType(): string {
+      let _result = Module.ccall(
+        "csp_systems_Scope__Get_ReferenceType",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set referenceType(value: string) {
+      Module.ccall(
+        "csp_systems_Scope__Set_ReferenceType",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get name(): string {
+      let _result = Module.ccall(
+        "csp_systems_Scope__Get_Name",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set name(value: string) {
+      Module.ccall(
+        "csp_systems_Scope__Set_Name",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get pubSubType(): Systems.PubSubModelType {
+      let _result = Module.ccall(
+        "csp_systems_Scope__Get_PubSubType",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set pubSubType(value: Systems.PubSubModelType) {
+      Module.ccall(
+        "csp_systems_Scope__Set_PubSubType",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    get solveRadius(): number {
+      let _result = Module.ccall(
+        "csp_systems_Scope__Get_SolveRadius",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set solveRadius(value: number) {
+      Module.ccall(
+        "csp_systems_Scope__Set_SolveRadius",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    get managedLeaderElection(): boolean {
+      let _result = Module.ccall(
+        "csp_systems_Scope__Get_ManagedLeaderElection",
+        "boolean",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set managedLeaderElection(value: boolean) {
+      Module.ccall(
+        "csp_systems_Scope__Set_ManagedLeaderElection",
+        "void",
+        ["number", "boolean"],
+        [this.pointer, value],
+      );
+    }
+  }
+}
+
+export namespace Systems {
+  /**
+@ingroup Multiplayer System
+ * @description Data representation for a scope leader.  
+ * A scope leader represents a user which owns a specific scope in a space.  
+ * The scope leader will run scripts and other operations for the scope.  
+ */
+  export class ScopeLeader
+    extends NativeClassWrapper
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static create(): ScopeLeader {
+      var _ptr = Module._malloc(8);
+      Module.ccall("csp_systems_ScopeLeader_Ctor", "void", ["number"], [_ptr]);
+      var _nPtr = getNativePointer(_ptr);
+
+      return new ScopeLeader(_nPtr);
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_ScopeLeader_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+
+    get scopeId(): string {
+      let _result = Module.ccall(
+        "csp_systems_ScopeLeader__Get_ScopeId",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set scopeId(value: string) {
+      Module.ccall(
+        "csp_systems_ScopeLeader__Set_ScopeId",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get scopeLeaderUserId(): string {
+      let _result = Module.ccall(
+        "csp_systems_ScopeLeader__Get_ScopeLeaderUserId",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set scopeLeaderUserId(value: string) {
+      Module.ccall(
+        "csp_systems_ScopeLeader__Set_ScopeLeaderUserId",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get electionInProgress(): boolean {
+      let _result = Module.ccall(
+        "csp_systems_ScopeLeader__Get_ElectionInProgress",
+        "boolean",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set electionInProgress(value: boolean) {
+      Module.ccall(
+        "csp_systems_ScopeLeader__Set_ElectionInProgress",
+        "void",
+        ["number", "boolean"],
+        [this.pointer, value],
+      );
+    }
+  }
+}
+
 export namespace Systems {
   /**
 @ingroup Quota System
@@ -55010,6 +55403,235 @@ export namespace Systems {
   }
 }
 
+export namespace Systems {
+  /**
+@ingroup Multiplayer System
+ * @description Public facing system that allows interfacing with Magnopus Connected Services' multiplayer api.  
+ * Offers methods for managing realtime state via REST calls.  
+ */
+  export class MultiplayerSystem extends Systems.SystemBase {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromSystemBase(
+      baseInstance: Systems.SystemBase,
+    ): Systems.MultiplayerSystem {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.MultiplayerSystem(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    static create(): MultiplayerSystem {
+      var _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_systems_MultiplayerSystem_Ctor",
+        "void",
+        ["number"],
+        [_ptr],
+      );
+      var _nPtr = getNativePointer(_ptr);
+
+      return new MultiplayerSystem(_nPtr);
+    }
+  }
+}
+
+export namespace Systems {
+  /**
+@ingroup Multiplayer System
+ * @description Contains details about an async operation which returns a scope.  
+ * If the ResultCode is successful, this will contain a valid scope.  
+ */
+  export class ScopeResult
+    extends Systems.ResultBase
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromResultBase(
+      baseInstance: Systems.ResultBase,
+    ): Systems.ScopeResult {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.ScopeResult(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    /**
+     * @description Returns the scope if this result is successful.
+     * @return The scope retrieved by this result.
+     */
+
+    getScope(): Systems.Scope {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_ScopeResult_GetScopeC_ScopeRC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Systems.Scope(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_ScopeResult_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
+export namespace Systems {
+  /**
+@ingroup Multiplayer System
+ * @description Contains details about an async operation which returns an array of scopes.  
+ * If the ResultCode is successful, this will contain a valid array of scopes.  
+ */
+  export class ScopesResult
+    extends Systems.ResultBase
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromResultBase(
+      baseInstance: Systems.ResultBase,
+    ): Systems.ScopesResult {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.ScopesResult(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    /**
+     * @description Returns the an array of scopes if this result is successful.
+     * @return The array of scopes retrieved by this result.
+     */
+
+    getScopes(): Common.Array<Systems.Scope> {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_ScopesResult_GetScopesC_ArrayRC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.Array<Systems.Scope>(
+        getNativePointer(_ret),
+        csp_systems_ScopeFactory,
+        "csp_systems_Scope",
+      );
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_ScopesResult_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
+export namespace Systems {
+  /**
+@ingroup Multiplayer System
+ * @description Contains details about an async operation which returns a scope leader.  
+ * If the ResultCode is successful, this will contain a valid scope leader.  
+ */
+  export class ScopeLeaderResult
+    extends Systems.ResultBase
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromResultBase(
+      baseInstance: Systems.ResultBase,
+    ): Systems.ScopeLeaderResult {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.ScopeLeaderResult(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    /**
+     * @description Returns the scope leader if this result is successful.
+     * @return The scope leader retrieved by this result.
+     */
+
+    getScopeLeader(): Systems.ScopeLeader {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_ScopeLeaderResult_GetScopeLeaderC_ScopeLeaderRC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Systems.ScopeLeader(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_ScopeLeaderResult_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
 export namespace Systems {
   /**
 @ingroup Quota System
@@ -63582,6 +64204,24 @@ export namespace Common {
       return _inst;
     }
 
+    static ofcsp_systems_Scope(): Array<Systems.Scope> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Ctor_csp_systems_Scope",
+        "void",
+        ["number"],
+        [_ret],
+      );
+      var _inst = new Array<Systems.Scope>(
+        getNativePointer(_ret),
+        csp_systems_ScopeFactory,
+        "csp_systems_Scope",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
     static ofcsp_systems_FeatureLimitInfo(): Array<Systems.FeatureLimitInfo> {
       var _ret = Module._malloc(8);
       Module.ccall(
@@ -64428,6 +65068,24 @@ export namespace Common {
       return _inst;
     }
 
+    static ofcsp_systems_Scope_number(size: number): Array<Systems.Scope> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Conv_size_tC_csp_systems_Scope",
+        "void",
+        ["number", "number"],
+        [_ret, size],
+      );
+      var _inst = new Array<Systems.Scope>(
+        getNativePointer(_ret),
+        csp_systems_ScopeFactory,
+        "csp_systems_Scope",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
     static ofcsp_systems_FeatureLimitInfo_number(
       size: number,
     ): Array<Systems.FeatureLimitInfo> {