@tencentcloud/roomkit-electron-vue3 2.4.1 → 2.5.0

package/es/services/function/errorHandler.mjs

@@ -0,0 +1,158 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { TUIErrorCode } from "@tencentcloud/tuiroom-engine-electron";
+import { EventType } from "../types.mjs";
+import { isElectron } from "../../utils/environment.mjs";
+class ErrorHandler {
+  constructor(service) {
+    __publicField(this, "service");
+    __publicField(this, "handlerMap", {
+      createRoom: this.handleCreateRoomError.bind(this),
+      enterRoom: this.handleEnterRoomError.bind(this),
+      onError: this.handleOnError.bind(this)
+    });
+    __publicField(this, "mediaDeviceErrorHandler", null);
+    this.service = service;
+  }
+  handleError(error, functionName) {
+    this.handlerMap[functionName] && this.handlerMap[functionName](error);
+  }
+  handleEnterRoomError(error) {
+    let message = "";
+    switch (error.code) {
+      case TUIErrorCode.ERR_ROOM_ID_NOT_EXIST:
+        message = "The room does not exist, please confirm the room number or create a room!";
+        break;
+      default:
+        message = "Failed to enter the meeting";
+    }
+    this.service.emit(EventType.ROOM_NOTICE_MESSAGE_BOX, {
+      title: this.service.t("Note"),
+      message: this.service.t(message),
+      confirmButtonText: this.service.t("Sure"),
+      callback: async () => {
+        this.service.emit(EventType.ROOM_ERROR, error);
+        this.service.roomStore.reset();
+      }
+    });
+  }
+  handleCreateRoomError(error) {
+    this.service.emit(EventType.ROOM_NOTICE_MESSAGE_BOX, {
+      title: this.service.t("Note"),
+      message: this.service.t("Failed to initiate meeting"),
+      confirmButtonText: this.service.t("Sure"),
+      callback: async () => {
+        this.service.emit(EventType.ROOM_ERROR, error);
+        this.service.resetStore();
+      }
+    });
+  }
+  handleOnError(error) {
+    if (error.message === "enter trtc room failed , error code : -1") {
+      this.service.emit(EventType.ROOM_NOTICE_MESSAGE_BOX, {
+        type: "warning",
+        message: this.service.t("Failed to enter the meeting"),
+        callback: () => {
+          this.service.emit(EventType.ROOM_ERROR);
+          this.service.resetStore();
+        }
+      });
+    }
+    if (error.code && String(error.code).indexOf("-11") === 0) {
+      if (!this.mediaDeviceErrorHandler) {
+        this.mediaDeviceErrorHandler = new MediaDeviceErrorHandler(this.service);
+      }
+      this.mediaDeviceErrorHandler.handleError(error);
+    }
+  }
+}
+class MediaDeviceErrorHandler {
+  constructor(service) {
+    __publicField(this, "service");
+    this.service = service;
+  }
+  getMediaDeviceErrorTitle(deviceType) {
+    return this.service.t("Unable to use the device", { deviceType: this.service.t(deviceType) });
+  }
+  getMediaDeviceErrorMsg(deviceType) {
+    return this.service.t("media device failed to open, please check the media device and try again", { deviceType: this.service.t(deviceType) });
+  }
+  getMediaDeviceNotAuthorizedMsg(deviceType) {
+    return this.service.t("The current device is not authorized, please allow access to the device permissions", { deviceType: this.service.t(deviceType) });
+  }
+  getMediaDeviceOccupiedMsg(deviceType) {
+    return this.service.t("The current device is occupied by other apps, try to close other apps or change the device", { deviceType: this.service.t(deviceType) });
+  }
+  getTurnOnDevicePrivilegesTitle(deviceType) {
+    return this.service.t("Turn on device privileges", { deviceType: this.service.t(deviceType) });
+  }
+  getTurnOnDevicePrivilegesMsg(deviceType) {
+    return this.service.t('You can go to "System Preferences - Security & Privacy - Device" to enable device permissions', { deviceType: this.service.t(deviceType) });
+  }
+  handleError(error) {
+    let mediaType;
+    let mediaErrorTitle = "";
+    let mediaErrorMsg = "";
+    let cancelButtonText = "";
+    let confirmButtonText = "";
+    let callback = null;
+    switch (error.code) {
+      case TUIErrorCode.ERR_CAMERA_START_FAILED:
+      case TUIErrorCode.ERR_MICROPHONE_START_FAILED:
+        mediaType = error.code === TUIErrorCode.ERR_CAMERA_START_FAILED ? "camera" : "microphone";
+        mediaErrorTitle = this.getMediaDeviceErrorTitle(mediaType);
+        mediaErrorMsg = this.getMediaDeviceErrorMsg(mediaType);
+        break;
+      case TUIErrorCode.ERR_CAMERA_NOT_AUTHORIZED:
+      case TUIErrorCode.ERR_MICROPHONE_NOT_AUTHORIZED:
+        mediaType = error.code === TUIErrorCode.ERR_CAMERA_NOT_AUTHORIZED ? "camera" : "microphone";
+        if (isElectron) {
+          mediaErrorTitle = this.getTurnOnDevicePrivilegesTitle(mediaType);
+          mediaErrorMsg = this.getTurnOnDevicePrivilegesMsg(mediaType);
+          cancelButtonText = this.service.t("Cancel");
+          confirmButtonText = this.service.t("Go to Settings");
+          callback = (action) => {
+            if (action === "confirm") {
+              this.goToPermissionSettings(mediaType);
+            }
+          };
+        } else {
+          mediaErrorTitle = this.getMediaDeviceErrorTitle(mediaType);
+          mediaErrorMsg = this.getMediaDeviceNotAuthorizedMsg(mediaType);
+        }
+        break;
+      case TUIErrorCode.ERR_CAMERA_OCCUPIED:
+      case TUIErrorCode.ERR_MICROPHONE_OCCUPIED:
+        mediaType = error.code === TUIErrorCode.ERR_CAMERA_OCCUPIED ? "camera" : "microphone";
+        mediaErrorTitle = this.getMediaDeviceErrorTitle(mediaType);
+        mediaErrorMsg = this.getMediaDeviceOccupiedMsg(mediaType);
+        break;
+    }
+    if (mediaErrorMsg) {
+      this.service.emit(EventType.ROOM_NOTICE_MESSAGE_BOX, {
+        type: "error",
+        title: mediaErrorTitle,
+        message: mediaErrorMsg,
+        cancelButtonText,
+        confirmButtonText: confirmButtonText || this.service.t("I got it"),
+        callback
+      });
+    }
+  }
+  goToPermissionSettings(deviceType) {
+    const { shell } = require("electron");
+    const privacyTypeObj = {
+      camera: "Privacy_Camera",
+      microphone: "Privacy_Microphone",
+      screenShare: "Privacy_ScreenCapture"
+    };
+    shell.openExternal(`x-apple.systempreferences:com.apple.preference.security?${privacyTypeObj[deviceType]}`);
+  }
+}
+export {
+  ErrorHandler
+};

package/es/services/function/virtualBackground.mjs

@@ -4,7 +4,7 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-import { isElectron } from "../../utils/environment.mjs";
+import { isElectron, isWeChat } from "../../utils/environment.mjs";
 class VirtualBackground {
   constructor(service) {
     __publicField(this, "service");
@@ -14,7 +14,7 @@ class VirtualBackground {
       await this.toggleTestVirtualBackground(false);
     });
     this.service = service;
-    if (isElectron)
+    if (isElectron || isWeChat)
       return;
     this.bindEvent();
   }
@@ -29,7 +29,8 @@ class VirtualBackground {
     this.service.lifeCycleManager.off("unmount", this.handleUnmount);
   }
   async initVirtualBackground() {
-    if (!this.virtualBackgroundPluginReady) {
+    var _a;
+    if (!this.virtualBackgroundPluginReady && ((_a = this.trtcCloud) == null ? void 0 : _a.useVirtualBackground)) {
       await this.trtcCloud.useVirtualBackground();
       this.virtualBackgroundPluginReady = true;
     }

package/es/services/index.d.ts

@@ -6,3 +6,4 @@ export * from './manager/configManager';
 export * from './manager/userManager';
 export * from './manager/lifeCycleManager';
 export * from './manager/roomActionManager';
+export * from './manager/scheduleConferenceManager';

package/es/services/manager/roomActionManager.d.ts

@@ -33,6 +33,7 @@ export declare class RoomActionManager {
     }): Promise<void>;
     private doEnterRoom;
     private getUserList;
+    private syncUserInfo;
     private getSeatList;
     private closeMediaBeforeLeave;
 }

package/es/services/manager/roomActionManager.mjs

@@ -110,15 +110,7 @@ class RoomActionManager {
       await this.handleRoomCreation(roomParams, options);
     } catch (error) {
       logger.error(`${logPrefix}createRoom error:`, error);
-      this.service.emit(EventType.ROOM_NOTICE_MESSAGE_BOX, {
-        title: this.service.t("Note"),
-        message: this.service.t("Failed to initiate meeting"),
-        confirmButtonText: this.service.t("Sure"),
-        callback: async () => {
-          this.service.emit(EventType.ROOM_ERROR, error);
-          this.service.resetStore();
-        }
-      });
+      this.service.errorHandler.handleError(error, "createRoom");
       throw error;
     }
   }
@@ -143,6 +135,7 @@ class RoomActionManager {
       const roomInfo = await this.doEnterRoom(roomParams);
       this.service.roomStore.setRoomInfo(roomInfo);
       await this.getUserList();
+      await this.syncUserInfo(this.service.basicStore.userId);
       if (roomInfo.isSeatEnabled) {
         await this.getSeatList();
         this.service.roomStore.isMaster && await ((_a = this.service.roomEngine.instance) == null ? void 0 : _a.takeSeat({
@@ -153,15 +146,7 @@ class RoomActionManager {
       this.service.roomStore.setRoomParam(roomParam);
     } catch (error) {
       logger.error(`${logPrefix}enterRoom error:`, error);
-      this.service.emit(EventType.ROOM_NOTICE_MESSAGE_BOX, {
-        title: this.service.t("Note"),
-        message: this.service.t("Failed to enter the meeting"),
-        confirmButtonText: this.service.t("Sure"),
-        callback: async () => {
-          this.service.emit(EventType.ROOM_ERROR, error);
-          this.service.roomStore.reset();
-        }
-      });
+      this.service.errorHandler.handleError(error, "enterRoom");
       throw error;
     }
   }
@@ -201,6 +186,13 @@ class RoomActionManager {
       logger.error("TUIRoomEngine.getUserList", error.code, error.message);
     }
   }
+  async syncUserInfo(userId) {
+    var _a;
+    const { roomEngine } = this.service;
+    const userInfo = await ((_a = roomEngine.instance) == null ? void 0 : _a.getUserInfo({ userId }));
+    const { isMessageDisabled } = userInfo;
+    this.service.chatStore.setSendMessageDisableChanged(isMessageDisabled);
+  }
   async getSeatList() {
     var _a;
     const { roomEngine } = this.service;

package/es/services/manager/scheduleConferenceManager.d.ts

@@ -0,0 +1,113 @@
+import { IRoomService } from '../types';
+import { TUIConferenceInfo, TUIConferenceListManagerEvents, TUIRoomType, TUISeatMode, TUIUserInfo, TUIConferenceStatus } from '@tencentcloud/tuiroom-engine-electron';
+
+export * from '@tencentcloud/tuiroom-engine-electron';
+interface IScheduleConferenceManager {
+    on(eventType: TUIConferenceListManagerEvents, callback: (data?: any) => any): void;
+    off(eventType: TUIConferenceListManagerEvents, callback: (data?: any) => void): void;
+    dispose(): void;
+    scheduleConference(conferenceInfo: IScheduleConferenceOptions): Promise<void>;
+    cancelConference(options: {
+        roomId: string;
+    }): Promise<void>;
+    updateConferenceInfo(options: {
+        roomId: string;
+        roomName?: string;
+        scheduleStartTime?: number;
+        scheduleEndTime?: number;
+    }): Promise<void>;
+    fetchScheduledConferenceList(options: {
+        statusArray?: TUIConferenceStatus[];
+        cursor: string;
+        count: number;
+    }): Promise<Array<TUIConferenceInfo>>;
+    fetchAttendeeList(options: {
+        roomId: string;
+        cursor: string;
+        count: number;
+    }): Promise<Array<TUIUserInfo>>;
+    addAttendeesByAdmin(options: {
+        roomId: string;
+        userIdList: string[];
+    }): Promise<void>;
+    removeAttendeesByAdmin(options: {
+        roomId: string;
+        userIdList: string[];
+    }): Promise<void>;
+    fetchFriendList(): Promise<void>;
+    replaceFriendList(userList: Array<{
+        userID: string;
+        avatar: string;
+        nick: string;
+    }>): void;
+}
+export interface IScheduleConferenceOptions {
+    scheduleStartTime: number;
+    scheduleEndTime: number;
+    scheduleAttendees?: string[];
+    reminderSecondsBeforeStart?: number;
+    roomId: string;
+    roomName?: string;
+    roomType?: TUIRoomType;
+    isSeatEnabled?: boolean;
+    seatMode?: TUISeatMode;
+    isMicrophoneDisableForAllUser?: boolean;
+    isScreenShareDisableForAllUser?: boolean;
+    isCameraDisableForAllUser?: boolean;
+    isMessageDisableForAllUser?: boolean;
+    maxSeatCount?: number;
+    password?: string;
+}
+export declare class ScheduleConferenceManager implements IScheduleConferenceManager {
+    private service;
+    private customFriendList?;
+    private emitter;
+    constructor(service: IRoomService);
+    dispose(): void;
+    on(eventType: TUIConferenceListManagerEvents, callback: (data?: any) => any): void;
+    off(eventType: TUIConferenceListManagerEvents, callback: (data?: any) => void): void;
+    private emit;
+    private bindEventContext;
+    private bindEvent;
+    private unbindEvent;
+    private onConferenceScheduled;
+    private onConferenceWillStart;
+    private onConferenceCancelled;
+    private onConferenceInfoChanged;
+    private onScheduleAttendeesChanged;
+    private onConferenceStatusChanged;
+    fetchFriendList(): Promise<any>;
+    replaceFriendList(userList: Array<{
+        userID: string;
+        avatar: string;
+        nick: string;
+    }>): void;
+    scheduleConference(options: IScheduleConferenceOptions): Promise<any>;
+    cancelConference(options: {
+        roomId: string;
+    }): Promise<any>;
+    updateConferenceInfo(options: {
+        roomId: string;
+        roomName?: string;
+        scheduleStartTime?: number;
+        scheduleEndTime?: number;
+    }): Promise<any>;
+    fetchScheduledConferenceList(options: {
+        statusArray?: TUIConferenceStatus[];
+        cursor: string;
+        count: number;
+    }): Promise<any>;
+    fetchAttendeeList(options: {
+        roomId: string;
+        cursor: string;
+        count: number;
+    }): Promise<any>;
+    addAttendeesByAdmin(options: {
+        roomId: string;
+        userIdList: string[];
+    }): Promise<any>;
+    removeAttendeesByAdmin(options: {
+        roomId: string;
+        userIdList: string[];
+    }): Promise<any>;
+}

package/es/services/manager/scheduleConferenceManager.mjs

@@ -0,0 +1,141 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { TUIConferenceListManagerEvents } from "@tencentcloud/tuiroom-engine-electron";
+export * from "@tencentcloud/tuiroom-engine-electron";
+import { EventType } from "../types.mjs";
+import mitt from "mitt";
+class ScheduleConferenceManager {
+  constructor(service) {
+    __publicField(this, "service");
+    __publicField(this, "customFriendList");
+    __publicField(this, "emitter", mitt());
+    this.service = service;
+    this.bindEventContext();
+    this.service.on(EventType.SERVICE_READY, () => {
+      this.bindEvent();
+    });
+  }
+  dispose() {
+    this.unbindEvent();
+  }
+  on(eventType, callback) {
+    this.emitter.on(eventType, callback);
+  }
+  off(eventType, callback) {
+    this.emitter.off(eventType, callback);
+  }
+  emit(eventType, data) {
+    this.emitter.emit(eventType, data);
+  }
+  bindEventContext() {
+    this.onConferenceScheduled = this.onConferenceScheduled.bind(this);
+    this.onConferenceWillStart = this.onConferenceWillStart.bind(this);
+    this.onConferenceCancelled = this.onConferenceCancelled.bind(this);
+    this.onConferenceInfoChanged = this.onConferenceInfoChanged.bind(this);
+    this.onScheduleAttendeesChanged = this.onScheduleAttendeesChanged.bind(this);
+    this.onConferenceStatusChanged = this.onConferenceStatusChanged.bind(this);
+  }
+  bindEvent() {
+    var _a;
+    const conferenceListManager = (_a = this.service.roomEngine) == null ? void 0 : _a.instance.getConferenceListManager();
+    conferenceListManager.on(TUIConferenceListManagerEvents.onConferenceScheduled, this.onConferenceScheduled);
+    conferenceListManager.on(TUIConferenceListManagerEvents.onConferenceWillStart, this.onConferenceWillStart);
+    conferenceListManager.on(TUIConferenceListManagerEvents.onConferenceCancelled, this.onConferenceCancelled);
+    conferenceListManager.on(TUIConferenceListManagerEvents.onConferenceInfoChanged, this.onConferenceInfoChanged);
+    conferenceListManager.on(
+      TUIConferenceListManagerEvents.onScheduleAttendeesChanged,
+      this.onScheduleAttendeesChanged
+    );
+    conferenceListManager.on(
+      TUIConferenceListManagerEvents.onConferenceStatusChanged,
+      this.onConferenceStatusChanged
+    );
+  }
+  unbindEvent() {
+    var _a;
+    const conferenceListManager = (_a = this.service.roomEngine) == null ? void 0 : _a.instance.getConferenceListManager();
+    conferenceListManager.off(TUIConferenceListManagerEvents.onConferenceScheduled, this.onConferenceScheduled);
+    conferenceListManager.off(TUIConferenceListManagerEvents.onConferenceWillStart, this.onConferenceWillStart);
+    conferenceListManager.off(TUIConferenceListManagerEvents.onConferenceCancelled, this.onConferenceCancelled);
+    conferenceListManager.off(TUIConferenceListManagerEvents.onConferenceInfoChanged, this.onConferenceInfoChanged);
+    conferenceListManager.off(
+      TUIConferenceListManagerEvents.onScheduleAttendeesChanged,
+      this.onScheduleAttendeesChanged
+    );
+    conferenceListManager.off(
+      TUIConferenceListManagerEvents.onConferenceStatusChanged,
+      this.onConferenceStatusChanged
+    );
+  }
+  onConferenceScheduled(data) {
+    this.emit(TUIConferenceListManagerEvents.onConferenceScheduled, data);
+  }
+  onConferenceWillStart(data) {
+    this.emit(TUIConferenceListManagerEvents.onConferenceWillStart, data);
+  }
+  onConferenceCancelled(data) {
+    this.emit(TUIConferenceListManagerEvents.onConferenceCancelled, data);
+  }
+  onConferenceInfoChanged(data) {
+    this.emit(TUIConferenceListManagerEvents.onConferenceInfoChanged, data);
+    const { roomId, roomName } = data.conferenceModifyInfo.basicRoomInfo;
+    const isCurrentRoom = this.service.basicStore.roomId === roomId;
+    if (!isCurrentRoom)
+      return;
+    roomName !== void 0 && roomName !== null && this.service.roomStore.setRoomInfo({
+      roomName
+    });
+  }
+  onScheduleAttendeesChanged(data) {
+    this.emit(TUIConferenceListManagerEvents.onScheduleAttendeesChanged, data);
+  }
+  onConferenceStatusChanged(data) {
+    this.emit(TUIConferenceListManagerEvents.onConferenceStatusChanged, data);
+  }
+  async fetchFriendList() {
+    var _a;
+    if (this.customFriendList)
+      return this.customFriendList;
+    const tim = (_a = this.service.roomEngine.instance) == null ? void 0 : _a.getTIM();
+    const { data } = await tim.getFriendList();
+    return data;
+  }
+  replaceFriendList(userList) {
+    this.customFriendList = userList;
+  }
+  async scheduleConference(options) {
+    var _a;
+    return await ((_a = this.service.roomEngine.instance) == null ? void 0 : _a.getConferenceListManager().scheduleConference(options));
+  }
+  async cancelConference(options) {
+    var _a;
+    return await ((_a = this.service.roomEngine.instance) == null ? void 0 : _a.getConferenceListManager().cancelConference(options));
+  }
+  async updateConferenceInfo(options) {
+    var _a;
+    return await ((_a = this.service.roomEngine.instance) == null ? void 0 : _a.getConferenceListManager().updateConferenceInfo(options));
+  }
+  async fetchScheduledConferenceList(options) {
+    var _a;
+    return await ((_a = this.service.roomEngine.instance) == null ? void 0 : _a.getConferenceListManager().fetchScheduledConferenceList(options));
+  }
+  async fetchAttendeeList(options) {
+    var _a;
+    return await ((_a = this.service.roomEngine.instance) == null ? void 0 : _a.getConferenceListManager().fetchAttendeeList(options));
+  }
+  async addAttendeesByAdmin(options) {
+    var _a;
+    return await ((_a = this.service.roomEngine.instance) == null ? void 0 : _a.getConferenceListManager().addAttendeesByAdmin(options));
+  }
+  async removeAttendeesByAdmin(options) {
+    var _a;
+    return await ((_a = this.service.roomEngine.instance) == null ? void 0 : _a.getConferenceListManager().removeAttendeesByAdmin(options));
+  }
+}
+export {
+  ScheduleConferenceManager
+};

package/es/services/manager/userManager.d.ts

@@ -1,3 +1,4 @@
+import { UserInfo } from '../../stores/room';
 import { IRoomService } from '../types';
 
 interface IUserManager {
@@ -18,5 +19,6 @@ export declare class UserManager implements IUserManager {
     constructor(service: IRoomService);
     setSelfInfo(options: SelfInfoOptions): Promise<void>;
     setCustomInfoForUser(options: CustomInfoForUser): Promise<any>;
+    getDisplayName(options: UserInfo): string;
 }
 export {};

package/es/services/manager/userManager.mjs

@@ -4,25 +4,29 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-import TUIRoomEngine from "@tencentcloud/tuiroom-engine-electron";
+import TUIRoomEngine__default from "@tencentcloud/tuiroom-engine-electron";
 class UserManager {
   constructor(service) {
     __publicField(this, "service");
     this.service = service;
   }
   async setSelfInfo(options) {
-    const { avatarUrl, userName } = await TUIRoomEngine.getSelfInfo();
+    const { avatarUrl, userName } = await TUIRoomEngine__default.getSelfInfo();
     const info = {
       userName: options.userName || userName,
       avatarUrl: options.avatarUrl || avatarUrl
     };
     this.service.basicStore.setBasicInfo(info);
-    return TUIRoomEngine.setSelfInfo(info);
+    return TUIRoomEngine__default.setSelfInfo(info);
   }
   async setCustomInfoForUser(options) {
     const roomEngine = this.service.roomEngine.instance;
     return roomEngine == null ? void 0 : roomEngine.setCustomInfoForUser(options);
   }
+  getDisplayName(options) {
+    const { nameCard, userName, userId } = options;
+    return nameCard || userName || userId;
+  }
 }
 export {
   UserManager

package/es/services/roomService.d.ts

@@ -1,3 +1,5 @@
+import { ErrorHandler } from './function/errorHandler';
+import { ScheduleConferenceManager } from './manager/scheduleConferenceManager';
 import { VirtualBackground } from './function/virtualBackground';
 import { WaterMark } from './function/waterMark';
 import { JoinParams, RoomActionManager, StartParams } from './manager/roomActionManager';
@@ -5,6 +7,7 @@ import { LifeCycleManager } from './manager/lifeCycleManager';
 import { SelfInfoOptions, UserManager } from './manager/userManager';
 import { ConfigManager, LanguageOption, ThemeOption } from './manager/configManager';
 import { ComponentConfig, ComponentManager, ComponentName } from './manager/componentManager';
+import { UserInfo } from '../stores/room';
 import { default as TUIRoomEngine } from '@tencentcloud/tuiroom-engine-electron';
 import { EventType, IRoomService, RoomInitData, RoomParam } from './types';
 
@@ -19,6 +22,8 @@ export declare class RoomService implements IRoomService {
     roomActionManager: RoomActionManager;
     waterMark: WaterMark;
     virtualBackground: VirtualBackground;
+    scheduleConferenceManager: ScheduleConferenceManager;
+    errorHandler: ErrorHandler;
     roomEngine: Record<string, TUIRoomEngine | null>;
     t: any;
     get basicStore(): any;
@@ -43,8 +48,10 @@ export declare class RoomService implements IRoomService {
     private onKickedOffLine;
     private onAllUserCameraDisableChanged;
     private handleVideoStateChange;
+    private onUserInfoChanged;
     private onAllUserMicrophoneDisableChanged;
     private handleAudioStateChange;
+    private onScreenShareForAllUserDisableChanged;
     resetStore(): void;
     private storeInit;
     initRoomKit(option: RoomInitData): Promise<void>;
@@ -75,5 +82,6 @@ export declare class RoomService implements IRoomService {
     setTheme(theme: ThemeOption): void;
     setLanguage(language: LanguageOption): void;
     setSelfInfo(options: SelfInfoOptions): Promise<void>;
+    getDisplayName(options: UserInfo): string;
 }
 export declare const roomService: RoomService;