@zegocloud/zego-uikit-prebuilt 1.0.2 → 1.3.0

package/{sdk/index.d.ts → index.d.ts}

@@ -1,9 +1,16 @@
 import { Root } from "react-dom/client";
-import { ZegoCloudRoomConfig } from "./model/index";
+import { LiveRole, ScenarioModel, ZegoCloudRoomConfig } from "./model/index";
 import { ZegoCloudRTCCore } from "./modules/index";
 export declare class ZegoUIKitPrebuilt {
     static core: ZegoCloudRTCCore;
     static _instance: ZegoUIKitPrebuilt;
+    static Host: LiveRole;
+    static Cohost: LiveRole;
+    static Audience: LiveRole;
+    static OneONoneCall: ScenarioModel;
+    static GroupCall: ScenarioModel;
+    static LiveStreaming: ScenarioModel;
+    static VideoConference: ScenarioModel;
     root: Root | undefined;
     static create(token: string): ZegoUIKitPrebuilt;
     joinRoom(roomConfig?: ZegoCloudRoomConfig): void;

package/{sdk/model → model}/index.d.ts

@@ -1,21 +1,45 @@
 import { ZegoUser, ZegoBroadcastMessageInfo } from "zego-express-engine-webrtm/sdk/code/zh/ZegoExpressEntity.d";
 import { ZegoCloudRTCCore } from "../modules";
-import { ZegoCloudUserList } from "../modules/tools/UserListManager";
+import { ZegoCloudUser, ZegoCloudUserList } from "../modules/tools/UserListManager";
 export interface ZegoCloudRemoteMedia {
-    media: MediaStream;
+    media: MediaStream | undefined;
     fromUser: ZegoUser;
     micStatus: "OPEN" | "MUTE";
     cameraStatus: "OPEN" | "MUTE";
     state: "NO_PLAY" | "PLAY_REQUESTING" | "PLAYING";
     streamID: string;
 }
+export declare enum LiveRole {
+    Host = "Host",
+    Cohost = "Cohost",
+    Audience = "Audience"
+}
+export declare enum ScenarioModel {
+    OneONoneCall = "OneONoneCall",
+    GroupCall = "GroupCall",
+    VideoConference = "VideoConference",
+    LiveStreaming = "LiveStreaming"
+}
+export interface ScenarioConfig {
+    [ScenarioModel.LiveStreaming]: {
+        role: LiveRole;
+    };
+    [ScenarioModel.OneONoneCall]: {
+        role: LiveRole;
+    };
+    [ScenarioModel.GroupCall]: {
+        role: LiveRole;
+    };
+    [ScenarioModel.VideoConference]: {
+        role: LiveRole;
+    };
+}
 export interface ZegoCloudRoomConfig {
     container?: HTMLElement | undefined | null;
     preJoinViewConfig?: {
         title?: string;
         invitationLink?: string;
     };
-    facingMode?: "user" | "environment";
     showPreJoinView?: boolean;
     turnOnMicrophoneWhenJoining?: boolean;
     turnOnCameraWhenJoining?: boolean;
@@ -28,19 +52,35 @@ export interface ZegoCloudRoomConfig {
         showUserJoinAndLeave?: boolean;
         showTextChat?: boolean;
     };
-    joinRoomCallback?: () => void;
-    leaveRoomCallback?: () => void;
-    userUpdateCallback?: (type: "ADD" | "DELETE", user: ZegoUser[]) => void;
-    roomTimerDisplayed?: boolean;
     branding?: {
         logoURL?: string;
     };
     showLeavingView?: boolean;
-    localizationJSON?: object;
     maxUsers?: number;
-    layout?: "Sidebar" | "Grid" | "Default";
+    layout?: "Sidebar" | "Grid" | "Auto";
     showNonVideoUser?: boolean;
     showOnlyAudioUser?: boolean;
+    useFrontFacingCamera?: boolean;
+    onJoinRoom?: (users: ZegoUser[]) => void;
+    onLeaveRoom?: (users: ZegoUser[]) => void;
+    onUserJoin?: (user: ZegoUser[]) => void;
+    onUserLeave?: (user: ZegoUser[]) => void;
+    sharedLinks?: {
+        name: string;
+        url: string;
+    }[];
+    showScreenSharingButton?: boolean;
+    scenario?: {
+        mode?: ScenarioModel;
+        config?: ScenarioConfig[ScenarioModel];
+    };
+    showLayoutButton?: boolean;
+    showPinButton?: boolean;
+    facingMode?: "user" | "environment";
+    joinRoomCallback?: () => void;
+    leaveRoomCallback?: () => void;
+    userUpdateCallback?: (updateType: "DELETE" | "ADD", userList: ZegoUser[]) => void;
+    roomTimerDisplayed?: boolean;
 }
 export interface ZegoBrowserCheckProp {
     core: ZegoCloudRTCCore;
@@ -93,8 +133,25 @@ export interface ZegoSidebarLayoutProps {
     };
     soundLevel?: SoundLevelMap;
 }
+export interface ZegoScreenSharingLayoutProps {
+    handleSetPin?: Function;
+    userList: ZegoCloudUserList;
+    videoShowNumber: number;
+    selfInfo: {
+        userID: string;
+    };
+    roomID?: String;
+    screenSharingUser: ZegoCloudUser;
+    soundLevel?: SoundLevelMap;
+    handleFullScreen?: (fullScreen: boolean) => void;
+}
 export interface SoundLevelMap {
     [userID: string]: {
         [streamID: string]: number;
     };
 }
+export declare enum ZegoStreamType {
+    main = 0,
+    media = 1,
+    screensharing = 2
+}

package/{sdk/modules → modules}/index.d.ts

@@ -30,7 +30,7 @@ export declare class ZegoCloudRTCCore {
     };
     checkWebRTC(): Promise<boolean>;
     _config: ZegoCloudRoomConfig;
-    setConfig(config: ZegoCloudRoomConfig): void;
+    setConfig(config: ZegoCloudRoomConfig): boolean;
     setPin(userID?: string, pined?: boolean): void;
     setMaxScreenNum(num: number): Promise<void>;
     setSidebarLayOut(enable: boolean): Promise<void>;
@@ -42,6 +42,7 @@ export declare class ZegoCloudRTCCore {
     setVolume(media: HTMLVideoElement, volume: number): void;
     createStream(source?: ZegoLocalStreamConfig): Promise<MediaStream>;
     setVideoConfig(media: MediaStream, constraints: ZegoPublishStreamConfig): Promise<ZegoServerResponse>;
+    stopPublishingStream(streamID: string): boolean;
     destroyStream(stream: MediaStream): void;
     useCameraDevice(media: MediaStream, deviceID: string): Promise<ZegoServerResponse>;
     useMicrophoneDevice(media: MediaStream, deviceID: string): Promise<ZegoServerResponse>;
@@ -50,11 +51,24 @@ export declare class ZegoCloudRTCCore {
     mutePublishStreamVideo(localStream: MediaStream, enable: boolean): Promise<boolean>;
     mutePublishStreamAudio(localStream: MediaStream, enable: boolean): Promise<boolean>;
     muteMicrophone(enable: boolean): Promise<boolean>;
+    extraInfoKey: string;
+    _roomExtraInfo: {
+        [index: string]: any;
+    };
+    set roomExtraInfo(value: {
+        [index: string]: any;
+    });
+    get roomExtraInfo(): {
+        [index: string]: any;
+    };
+    setLive(status: "live" | "stop"): Promise<boolean>;
     enterRoom(): Promise<number>;
-    publishLocalStream(media: MediaStream): boolean | string;
+    publishLocalStream(media: MediaStream, streamType?: "main" | "media" | "screensharing"): boolean | string;
     replaceTrack(media: MediaStream, mediaStreamTrack: MediaStreamTrack): Promise<ZegoServerResponse>;
     private subscribeUserListCallBack;
     subscribeUserList(callback: (userList: ZegoCloudUserList) => void): void;
+    private subscribeScreenStreamCallBack;
+    subscribeScreenStream(callback: (userList: ZegoCloudUserList) => void): void;
     private onRemoteMediaUpdateCallBack;
     onRemoteMediaUpdate(func: (updateType: "DELETE" | "ADD" | "UPDATE", streamList: ZegoCloudRemoteMedia[]) => void): void;
     private onNetworkStatusQualityCallBack;
@@ -63,9 +77,13 @@ export declare class ZegoCloudRTCCore {
     onRemoteUserUpdate(func: (roomID: string, updateType: "DELETE" | "ADD", user: ZegoUser[]) => void): void;
     private onSoundLevelUpdateCallBack;
     onSoundLevelUpdate(func: (soundLevelList: ZegoSoundLevelInfo[]) => void): void;
+    private onRoomLiveStateUpdateCallBack;
+    onRoomLiveStateUpdate(func: (live: 1 | 0) => void): void;
     sendRoomMessage(message: string): Promise<import("zego-express-engine-webrtm/sdk/code/zh/ZegoExpressEntity.d").ZegoServerResponse>;
     private onRoomMessageUpdateCallBack;
     onRoomMessageUpdate(func: (roomID: string, info: ZegoBroadcastMessageInfo[]) => void): void;
+    private onScreenSharingEndedCallBack;
+    onScreenSharingEnded(func: (stream: MediaStream) => void): void;
     NetworkStatusTimer: NodeJS.Timer | null;
     private onNetworkStatusCallBack;
     onNetworkStatus(func: (roomID: string, type: "ROOM" | "STREAM", status: "DISCONNECTED" | "CONNECTING" | "CONNECTED") => void): void;

package/{sdk/modules → modules}/tools/UserListManager.d.ts

@@ -1,6 +1,6 @@
 import { ZegoExpressEngine } from "zego-express-engine-webrtc";
 import { ZegoUser } from "zego-express-engine-webrtm/sdk/code/zh/ZegoExpressEntity.d";
-import { ZegoCloudRemoteMedia } from "../../model";
+import { LiveRole, ScenarioModel, ZegoCloudRemoteMedia } from "../../model";
 export declare type ZegoCloudUserList = ZegoCloudUser[];
 export declare type ZegoCloudUser = ZegoUser & {
     pin: boolean;
@@ -11,9 +11,11 @@ export declare class ZegoCloudUserListManager {
     private zg;
     constructor(zg: ZegoExpressEngine);
     showNonVideo: boolean;
+    showOnlyAudioUser: boolean;
     screenNumber: number;
     sidebarEnabled: boolean;
     remoteUserList: ZegoCloudUserList;
+    remoteScreenStreamList: ZegoCloudUserList;
     setPin(userID?: string, pined?: boolean): void;
     setShowNonVideo(enable: boolean): Promise<boolean>;
     setMaxScreenNum(num: number): Promise<boolean>;
@@ -21,7 +23,19 @@ export declare class ZegoCloudUserListManager {
     updateStream(): Promise<boolean>;
     openVideo(user: ZegoCloudUser): Promise<void>;
     muteVideo(user: ZegoCloudUser): Promise<void>;
-    userUpdate(roomID: string, updateType: "DELETE" | "ADD", users: ZegoUser[]): void;
-    streamNumUpdate(updateType: "DELETE" | "ADD" | "UPDATE", streamList: ZegoCloudRemoteMedia[]): void;
-    clearUserList(): void;
+    userOrderList: string[];
+    userUpdate(roomID: string, updateType: "DELETE" | "ADD", users: ZegoUser[]): Promise<boolean>;
+    mainStreamUpdate(updateType: "DELETE" | "ADD" | "UPDATE", streamList: ZegoCloudRemoteMedia[]): void;
+    screenStreamUpdate(updateType: "DELETE" | "ADD" | "UPDATE", streamList: ZegoCloudRemoteMedia[]): void;
+    waitingPullStreams: {
+        streamID: string;
+        userID: string;
+    }[];
+    isLive: 1 | 0;
+    setLiveStates(state: 1 | 0): Promise<void>;
+    scenario: ScenarioModel;
+    role: LiveRole;
+    startPullStream(userID: string, streamID: string): Promise<MediaStream | undefined>;
+    stopPullStream(userID: string, streamID: string): void;
+    reset(): void;
 }

package/{sdk/modules → modules}/tools/util.d.ts

@@ -8,3 +8,4 @@ export declare function getConfig(token: string): {
 } | undefined;
 export declare function copy(text: string): void;
 export declare function formatTime(s: number): string;
+export declare function generateStreamID(userID: string, roomID: string, type?: "main" | "media" | "screensharing"): string;

package/package.json

@@ -1,6 +1,6 @@
 {
             "name": "@zegocloud/zego-uikit-prebuilt",
-            "version": "1.0.2",
+            "version": "1.3.0",
             "description": "zegocloud prebuilt meeting webrtc sdk",
             "main": "./zego-uikit-prebuilt.js",
             "typings": "./sdk/index.d.ts",

package/{sdk/view → view}/components/zegoSetting/index.d.ts

@@ -7,10 +7,10 @@ export declare class ZegoSettings extends React.Component<ZegoSettingsProps> {
     state: {
         visible: boolean;
         selectTab: "AUDIO" | "VIDEO";
-        seletMic: string | undefined;
-        seletSpeaker: string | undefined;
-        seletCamera: string | undefined;
-        seletVideoResolution: string | undefined;
+        selectMic: string | undefined;
+        selectSpeaker: string | undefined;
+        selectCamera: string | undefined;
+        selectVideoResolution: string | undefined;
         micDevices: ZegoDeviceInfo[];
         speakerDevices: ZegoDeviceInfo[];
         cameraDevices: ZegoDeviceInfo[];
@@ -37,10 +37,10 @@ export declare class ZegoSettings extends React.Component<ZegoSettingsProps> {
         micDevices: ZegoDeviceInfo[];
         speakerDevices: ZegoDeviceInfo[];
         cameraDevices: ZegoDeviceInfo[];
-        seletMic: string | undefined;
-        seletSpeaker: string | undefined;
-        seletCamera: string | undefined;
-        seletVideoResolution: string | undefined;
+        selectMic: string | undefined;
+        selectSpeaker: string | undefined;
+        selectCamera: string | undefined;
+        selectVideoResolution: string | undefined;
     }>;
     createVideoStream(): Promise<boolean>;
     createAudioStream(): Promise<boolean>;

package/{sdk/view/components/mobile → view/components}/zegoToast/index.d.ts

@@ -4,10 +4,6 @@ export declare class ZegoToastComponents extends React.Component<{
     content?: string;
     duration: number;
 }> {
-    state: {
-        mounted: boolean;
-    };
-    componentDidMount(): void;
     render(): React.ReactNode;
 }
 export declare const ZegoToast: (config?: {

package/{sdk/view → view}/pages/ZegoBrowserCheck/index.d.ts

@@ -13,12 +13,17 @@ export declare class ZegoBrowserCheck extends React.Component<ZegoBrowserCheckPr
         isJoinRoomFailed: boolean;
         joinRoomErrorTip: string;
         showDeviceAuthorAlert: boolean;
-        seletMic: undefined;
-        seletSpeaker: undefined;
-        seletCamera: undefined;
-        seletVideoResolution: string;
+        selectMic: undefined;
+        selectSpeaker: undefined;
+        selectCamera: undefined;
+        selectVideoResolution: string;
         isJoining: boolean;
         showNonVideo: boolean | undefined;
+        sharedLinks: {
+            name: string;
+            url: string;
+            copied: boolean;
+        }[] | undefined;
     };
     videoRef: RefObject<HTMLVideoElement>;
     inviteRef: RefObject<HTMLInputElement>;
@@ -27,16 +32,15 @@ export declare class ZegoBrowserCheck extends React.Component<ZegoBrowserCheckPr
     constructor(props: ZegoBrowserCheckProp);
     componentDidMount(): Promise<void>;
     getDevices(): Promise<{
-        seletMic: string | undefined;
-        seletSpeaker: string | undefined;
-        seletCamera: string | undefined;
-        seletVideoResolution: string;
+        selectMic: string | undefined;
+        selectSpeaker: string | undefined;
+        selectCamera: string | undefined;
+        selectVideoResolution: string;
     }>;
     createStream(videoOpen: boolean, audioOpen: boolean): Promise<MediaStream>;
     toggleStream(type: "video" | "audio"): Promise<void>;
     joinRoom(): Promise<void>;
     handleChange(event: ChangeEvent<HTMLInputElement>): void;
-    handleCopy(): void;
     openSettings(): void;
     render(): React.ReactNode;
 }

package/{sdk/view → view}/pages/ZegoBrowserCheckMobile/index.d.ts

@@ -11,6 +11,11 @@ export declare class ZegoBrowserCheckMobile extends React.Component<ZegoBrowserC
         copied: boolean;
         isVideoOpening: boolean;
         isJoining: boolean;
+        sharedLinks: {
+            name: string;
+            url: string;
+            copied: boolean;
+        }[] | undefined;
     };
     videoRef: RefObject<HTMLVideoElement>;
     inviteRef: RefObject<HTMLInputElement>;
@@ -19,6 +24,8 @@ export declare class ZegoBrowserCheckMobile extends React.Component<ZegoBrowserC
     constructor(props: ZegoBrowserCheckProp);
     componentDidMount(): Promise<void>;
     createStream(videoOpen: boolean, audioOpen: boolean): Promise<MediaStream>;
+    toggleStream2(type: "video" | "audio"): Promise<void>;
+    toggleStream1(type: "video" | "audio"): Promise<void>;
     toggleStream(type: "video" | "audio"): Promise<void>;
     joinRoom(): Promise<void>;
     handleChange(event: ChangeEvent<HTMLInputElement>): void;

package/view/pages/ZegoRoom/components/ZegoScreenSharingLayout.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { ZegoScreenSharingLayoutProps } from "../../../../model";
+export declare class ZegoScreenSharingLayout extends React.Component<ZegoScreenSharingLayoutProps> {
+    state: {
+        fullScreen: boolean;
+        loadingMask: boolean;
+        showBottomTip: boolean;
+    };
+    componentDidMount(): void;
+    onCanPlay(): void;
+    handleIgnore(): void;
+    render(): React.ReactNode;
+}

package/{sdk/view → view}/pages/ZegoRoom/components/zegoOne2One.d.ts

@@ -6,7 +6,7 @@ export declare class ZegoOne2One extends React.Component<{
         userID: string;
     };
     onLocalStreamPaused: () => void;
-    handleSetPin: Function;
+    handleSetPin?: Function;
     soundLevel?: SoundLevelMap;
     userList: ZegoCloudUser[];
 }> {

package/{sdk/view → view}/pages/ZegoRoom/components/zegoRoomInvite.d.ts

@@ -1,9 +1,8 @@
-import React, { RefObject } from "react";
+import React from "react";
 import { ZegoCloudRTCCore } from "../../../../modules";
 export declare class ZegoRoomInvite extends React.Component<{
     core: ZegoCloudRTCCore;
 }> {
-    inviteRef: RefObject<HTMLInputElement>;
-    handleCopy(): void;
+    handleCopy(url: string): void;
     render(): React.ReactNode;
 }

package/{sdk/view → view}/pages/ZegoRoom/components/zegoUserList.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 import { ZegoCloudRTCCore } from "../../../../modules";
-import { ZegoCloudUserList } from "../../../../modules/tools/UserListManager";
+import { ZegoCloudUser, ZegoCloudUserList } from "../../../../modules/tools/UserListManager";
 import { SoundLevelMap } from "../../../../model";
 export declare class ZegoUserList extends React.Component<{
     core: ZegoCloudRTCCore;
@@ -14,5 +14,6 @@ export declare class ZegoUserList extends React.Component<{
     onBodyClick(e: Event): void;
     expandMemberMenu(userID: string | null): void;
     getHeight(userID: string, streamID: string): number;
+    isShownPin(user: ZegoCloudUser): boolean;
     render(): React.ReactNode;
 }

package/view/pages/ZegoRoom/components/zegoVideoPlayer.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import { ZegoCloudUser } from "../../../../modules/tools/UserListManager";
+import ShowPCManageContext, { ShowPCManageType } from "../context/showManage";
+export declare class VideoPlayer extends React.Component<{
+    userInfo: ZegoCloudUser;
+    muted: boolean;
+    volume?: {
+        [streamID: string]: number;
+    };
+    handlePin?: Function;
+    onPause?: Function;
+    onCanPlay?: Function;
+    myClass?: string;
+    hiddenName?: boolean;
+    hiddenMore?: boolean;
+}> {
+    static contextType?: React.Context<ShowPCManageType>;
+    context: React.ContextType<typeof ShowPCManageContext>;
+    render(): React.ReactNode;
+}

package/view/pages/ZegoRoom/context/showManage.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import { ZegoCloudUser } from "../../../../modules/tools/UserListManager";
+export declare type ShowPCManageType = {
+    show?: (user: ZegoCloudUser) => void;
+    showPinButton: boolean;
+};
+declare const ShowPCManageContext: React.Context<ShowPCManageType>;
+export default ShowPCManageContext;

package/{sdk/view → view}/pages/ZegoRoom/index.d.ts

@@ -1,12 +1,10 @@
 /// <reference types="node" />
 import React, { RefObject } from "react";
-import { SoundLevelMap, ZegoBroadcastMessageInfo2, ZegoBrowserCheckProp, ZegoCloudRemoteMedia, ZegoNotification } from "../../../model";
-import { ZegoUser } from "zego-express-engine-webrtm/sdk/code/zh/ZegoExpressEntity.d";
+import { SoundLevelMap, ZegoBroadcastMessageInfo2, ZegoBrowserCheckProp, ZegoNotification } from "../../../model";
 import { ZegoCloudUserList } from "../../../modules/tools/UserListManager";
 export declare class ZegoRoom extends React.Component<ZegoBrowserCheckProp> {
     state: {
         localStream: undefined | MediaStream;
-        remoteStreamInfo: ZegoCloudRemoteMedia | undefined;
         layOutStatus: "ONE_VIDEO" | "INVITE" | "USER_LIST" | "MESSAGE";
         zegoCloudUserList: ZegoCloudUserList;
         messageList: ZegoBroadcastMessageInfo2[];
@@ -17,17 +15,22 @@ export declare class ZegoRoom extends React.Component<ZegoBrowserCheckProp> {
         isNetworkPoor: boolean;
         connecting: boolean;
         firstLoading: boolean;
-        seletMic: string | undefined;
-        seletSpeaker: string | undefined;
-        seletCamera: string | undefined;
-        seletVideoResolution: string;
+        selectMic: string | undefined;
+        selectSpeaker: string | undefined;
+        selectCamera: string | undefined;
+        selectVideoResolution: string;
         showNonVideoUser: boolean;
         videoShowNumber: number;
         gridRowNumber: number;
-        layout: "Default" | "Grid" | "Sidebar";
+        layout: "Auto" | "Grid" | "Sidebar";
         showLayoutSettingsModel: boolean;
         isLayoutChanging: boolean;
         soundLevel: SoundLevelMap;
+        liveCountdown: number;
+        liveStatus: 1 | 0;
+        isScreenSharingBySelf: boolean;
+        screenSharingStream: undefined | MediaStream;
+        screenSharingUserList: ZegoCloudUserList;
     };
     settingsRef: RefObject<HTMLDivElement>;
     moreRef: RefObject<HTMLDivElement>;
@@ -37,13 +40,15 @@ export declare class ZegoRoom extends React.Component<ZegoBrowserCheckProp> {
     msgDelayed: boolean;
     localUserPin: boolean;
     localStreamID: string;
+    screenSharingStreamID: string;
+    isCreatingScreenSharing: boolean;
+    fullScreen: boolean;
     userUpdateCallBack: () => void;
     componentDidMount(): void;
     componentDidUpdate(preProps: ZegoBrowserCheckProp, preState: {
         localStream: undefined | MediaStream;
-        remoteStreamInfo: ZegoCloudRemoteMedia | undefined;
         layOutStatus: "ONE_VIDEO" | "INVITE" | "USER_LIST" | "MESSAGE";
-        zegoCloudUserList: ZegoUser[];
+        zegoCloudUserList: ZegoCloudUserList;
         messageList: ZegoBroadcastMessageInfo2[];
         notificationList: ZegoNotification[];
         micOpen: boolean;
@@ -51,12 +56,18 @@ export declare class ZegoRoom extends React.Component<ZegoBrowserCheckProp> {
         showMore: boolean;
         layout: string;
         videoShowNumber: number;
+        liveStatus: 1 | 0;
+        isScreenSharingBySelf: boolean;
+        screenSharingUserList: ZegoCloudUserList;
     }): void;
     componentWillUnmount(): void;
     initSDK(): Promise<void>;
     createStream(): Promise<boolean>;
     toggleMic(): Promise<void>;
     toggleCamera(): Promise<boolean>;
+    toggleScreenSharing(): Promise<void>;
+    createScreenSharing(): Promise<void>;
+    closeScreenSharing(): void;
     toggleLayOut(layOutStatus: "ONE_VIDEO" | "INVITE" | "USER_LIST" | "MESSAGE"): void;
     sendMessage(msg: string): Promise<void>;
     openSettings(): void;
@@ -64,13 +75,33 @@ export declare class ZegoRoom extends React.Component<ZegoBrowserCheckProp> {
     handleSetting(): void;
     handleLeave(): void;
     leaveRoom(): void;
-    computeByResize(): void;
+    computeByResize(): Promise<void>;
     onWindowResize: () => void;
     showLayoutSettings(show: boolean): void;
     changeLayout(type: string): Promise<unknown>;
+    getAllUser(): (import("../../../modules/tools/UserListManager").ZegoCloudUser | {
+        userID: string;
+        userName: string;
+        pin: boolean;
+        streamList: {
+            media: MediaStream;
+            fromUser: {
+                userID: string;
+                userName: string;
+            };
+            micStatus: string;
+            cameraStatus: string;
+            state: string;
+            streamID: string;
+        }[];
+    })[];
     getShownUser(forceShowNonVideoUser?: boolean): ZegoCloudUserList;
+    get getScreenSharingUser(): ZegoCloudUserList;
     getHiddenUser(): JSX.Element;
     getLayoutScreen(): JSX.Element | undefined;
     handleSetPin(userID: string): void;
+    handleFullScreen(fullScreen: boolean): void;
+    setLive(): Promise<void>;
+    liveCountdownTimer(): void;
     render(): React.ReactNode;
 }

package/view/pages/ZegoRoomMobile/components/zegoLayout.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+export declare class ZegoLayout extends React.Component<{
+    selectLayout: "Sidebar" | "Grid" | "Auto";
+    closeCallBac: () => void;
+    selectCallBack?: (selectLayout: "Sidebar" | "Grid" | "Auto") => Promise<boolean>;
+}> {
+    state: {
+        selectLayout: "Sidebar" | "Grid" | "Auto";
+    };
+    checking: boolean;
+    select(selectLayout: "Sidebar" | "Grid" | "Auto"): Promise<void>;
+    render(): React.ReactNode;
+}

package/view/pages/ZegoRoomMobile/components/zegoScreen.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { ZegoScreenSharingLayoutProps } from "../../../../model";
+export declare class ZegoScreen extends React.Component<ZegoScreenSharingLayoutProps> {
+    state: {
+        loading: boolean;
+    };
+    onCanPlay(): void;
+    render(): React.ReactNode;
+}

package/{sdk/view → view}/pages/ZegoRoomMobile/components/zegoUserList.d.ts

@@ -10,5 +10,6 @@ export declare class ZegoUserList extends React.Component<{
         message: string;
     };
     messageInput(event: ChangeEvent<HTMLInputElement>): void;
+    isShownPin(user: ZegoCloudUser): boolean;
     render(): React.ReactNode;
 }