import { ChatSDK } from '@tencentcloud/chat';
export { default as TIM, default as TencentCloudChat } from '@tencentcloud/chat';
import TRTCCloud, { TRTCScreenCaptureSourceInfo, TRTCDeviceInfo } from 'trtc-cloud-js-sdk';
export { Rect, default as TRTCCloud, TRTCDeviceInfo, TRTCDeviceState, TRTCDeviceType, TRTCLogLevel, TRTCScreenCaptureSourceInfo, TRTCScreenCaptureSourceType, TRTCVideoEncParam, TRTCVideoFillMode, TRTCVideoMirrorType, TRTCVideoResolution, TRTCVideoResolutionMode, TRTCVideoRotation, TRTCVideoStreamType, TRTCVolumeInfo } from 'trtc-cloud-js-sdk';

declare enum TUIErrorCode {
    ERR_SUCC = 0,
    ERR_FAILED = -1,
    ERR_FREQ_LIMIT = -2,
    ERR_REPEAT_OPERATION = -3,
    ERR_SDKAPPID_NOT_FOUND = -1000,
    ERR_INVALID_PARAMETER = -1001,
    ERR_SDK_NOT_INITIALIZED = -1002,
    ERR_PERMISSION_DENIED = -1003,
    ERR_REQUIRE_PAYMENT = -1004,
    ERR_CAMERA_START_FAILED = -1100,
    ERR_CAMERA_NOT_AUTHORIZED = -1101,
    ERR_CAMERA_OCCUPIED = -1102,
    ERR_CAMERA_DEVICE_EMPTY = -1103,
    ERR_MICROPHONE_START_FAILED = -1104,
    ERR_MICROPHONE_NOT_AUTHORIZED = -1105,
    ERR_MICROPHONE_OCCUPIED = -1106,
    ERR_MICROPHONE_DEVICE_EMPTY = -1107,
    ERR_GET_SCREEN_SHARING_TARGET_FAILED = -1108,
    ERR_START_SCREEN_SHARING_FAILED = -1109,
    ERR_ALREADY_ROOM_OWNER = -1200,
    ERR_IM_ATTRIBUTE_WRITE_CONFLICT = -1201,
    ERR_ALREADY_ROOM_ENTER = -1202,
    ERR_DESTROY_ROOM_NO_PERMISSION = -1203,
    ERR_LIVE_REQUEST_SERVER_TIMEOUT = -1300,
    ERR_LIVE_SERVER_PROCESS_FAILED = -1301,
    ERR_LIVE_DISCONNECTED = -1302,
    ERR_LIVE_NO_AVAILABLE_HEVC_DECODERS = -1303,
    ERR_OPERATION_INVALID_BEFORE_ENTER_ROOM = -2101,
    ERR_EXIT_NOT_SUPPORTED_FOR_ROOM_OWNER = -2102,
    ERR_OPERATION_NOT_SUPPORTED_IN_CURRENT_ROOM_TYPE = -2103,
    ERR_ROOM_ID_INVALID = -2105,
    ERR_ROOM_NAME_INVALID = -2107,
    ERR_ALREADY_IN_OTHER_ROOM = -2108,
    ERR_USER_NOT_EXIST = -2200,
    ERR_NEED_OWNER_PERMISSION = -2300,
    ERR_NEED_ADMIN_PERMISSION = -2301,
    ERR_REQUEST_NO_PERMISSION = -2310,
    ERR_REQUEST_ID_INVALID = -2311,
    ERR_REQUEST_ID_REPEAT = -2312,
    ERR_MAX_SEAT_COUNT_LIMIT = -2340,
    ERR_SEAT_INDEX_NOT_EXIST = -2344,
    ERR_OPEN_MICROPHONE_NEED_SEAT_UNLOCK = -2360,
    ERR_OPEN_MICROPHONE_NEED_PERMISSION_FROM_ADMIN = -2361,
    ERR_OPEN_CAMERA_NEED_SEAT_UNLOCK = -2370,
    ERR_OPEN_CAMERA_NEED_PERMISSION_FROM_ADMIN = -2371,
    ERR_OPEN_SCREEN_SHARE_NEED_SEAT_UNLOCK = -2372,
    ERR_OPEN_SCREEN_SHARE_NEED_PERMISSION_FROM_ADMIN = -2373,
    ERR_SEND_MESSAGE_DISABLED_FOR_ALL = -2380,
    ERR_SEND_MESSAGE_DISABLED_FOR_CURRENT = -2381,
    ERR_ROOM_ID_OCCUPIED = 100003,
    ERR_ROOM_ID_NOT_EXIST = 100004,
    ERR_USER_NOT_ENTERED = 100005,
    ERR_NEED_PASSWORD = 100018,
    ERR_WRONG_PASSWORD = 100019,
    ERR_ROOM_USER_FULL = 100008,
    ERR_REQUEST_CONFLICT = 100102,
    ERR_SEAT_OCCUPIED = 100210,
    ERR_ALREADY_IN_SEAT = 100203,
    ERR_SEAT_LOCKED = 100200,
    ERR_ALL_SEAT_OCCUPIED = 100205,
    ERR_USER_NOT_IN_SEAT = 100206,
    ERR_SEAT_NOT_SUPPORT_LINK_MIC = 100211,
    ERR_ROOM_ALREADY_CONNECTED = 100401,
    ERR_ROOM_CONNECTED_IN_OTHER = 100403,
    ERR_MAX_CONNECTED_COUNT_LIMIT = 100404,
    ERR_BATTLE_IN_RUNNING = 100419,
    ERR_BATTLE_ID_NOT_EXIST = 100411,
    ERR_ROOM_BATTLEID_IN_OTHER = 100415,
    ERR_ROOM_METADATA_EXCEED_KEY_COUNT_LIMIT = 100500,
    ERR_ROOM_METADATA_EXCEED_VALUE_SIZE_LIMIT = 100501
}
type TUIRoomInfo = {
    roomId: string;
    roomName: string;
    roomType: TUIRoomType;
    isSeatEnabled: boolean;
    seatMode: TUISeatMode;
    password: string;
    isMicrophoneDisableForAllUser: boolean;
    isScreenShareDisableForAllUser: boolean;
    isCameraDisableForAllUser: boolean;
    isMessageDisableForAllUser: boolean;
    maxSeatCount: number;
    roomOwner: string;
    ownerId: string;
    ownerName: string;
    ownerAvatarUrl: string;
    createTime: number;
    roomMemberCount: number;
};
type TUIEnterRoomOptions = {
    password?: string;
};
type TUILoginUserInfo = {
    userId: string;
    userName: string;
    avatarUrl: string;
    customInfo: Record<string, any>;
};
type TUISeatLockParams = {
    lockSeat: boolean;
    lockVideo: boolean;
    lockAudio: boolean;
};
declare enum TUIRole {
    kRoomOwner = 0,
    kAdministrator = 1,
    kGeneralUser = 2
}
/**
 * 消息结构体
 * @typedef {object} TUIMessage
 * @property {string} messageId 消息 Id
 * @property {string} message 消息内容
 * @property {number} timestamp 时间戳信息, 精确到秒
 * @property {TUIRole} userId 用户 Id
 * @property {boolean} userName 用户名称
 * @property {boolean} avatarUrl 用户头像地址
 */
type TUIMessage = {
    messageId: string;
    message: string;
    timestamp: number;
    userId: string;
    userName: string;
    avatarUrl: string;
};
declare enum TUIVideoQuality {
    kVideoQuality_360p = 1,
    kVideoQuality_540p = 2,
    kVideoQuality_720p = 3,
    kVideoQuality_1080p = 4
}
declare enum TUIAudioQuality {
    kAudioProfileSpeech = 0,
    kAudioProfileDefault = 1,
    kAudioProfileMusic = 2
}
declare enum TUIVideoStreamType {
    kCameraStream = 0,
    kScreenStream = 1,
    kCameraStreamLow = 2
}
declare enum TUINetworkQuality {
    kQualityUnknown = 0,
    kQualityExcellent = 1,
    kQualityGood = 2,
    kQualityPoor = 3,
    kQualityBad = 4,
    kQualityVeryBad = 5,
    kQualityDown = 6
}
/**
 * 消息结构体
 * @typedef {object} TUINetwork
 * @property {string} userId 用户 Id
 * @property {TUINetworkQuality} quality 网络质量
 * @property {number} upLoss 上行丢包率，单位 (%) 该数值越小越好，目前仅本地用户有该信息
 * @property {TUIRole} downLoss 下行丢包率，单位 (%) 该数值越小越好，目前仅本地用户有该信息
 * @property {Number} delay 网络延迟，单位 ms，目前仅本地用户有该信息
 */
type TUINetwork = {
    userId: string;
    quality: TUINetworkQuality;
    upLoss: number;
    downLoss: number;
    delay: number;
};
/**
 * 视频编码参数
 * @typedef {object} TUIVideoEncoderParams
 * @property {number} fps 帧率设置
 * @property {number} bitrate 目标编码码率设置
 * @property {TUIVideoQuality} quality 上行视频分辨率
 * @property {TUIVideoQuality} videoResolution 上行视频分辨率（自 v1.6.0 版本开始支持，v1.6.0 之前版本请使用 quality 参数）
 * @property {TUIResolutionMode} resolutionMode 横竖屏模式
 */
type TUIVideoEncoderParams = {
    quality?: TUIVideoQuality;
    videoResolution: TUIVideoQuality;
    fps: number;
    bitrate: number;
    resolutionMode: TUIResolutionMode;
};
declare enum TUIRoomType {
    kConference = 1,
    kLive = 2
}
declare enum TUISeatMode {
    kFreeToTake = 1,
    kApplyToTake = 2
}
declare enum TUIMediaDevice {
    kMicrophone = 1,
    kCamera = 2,
    kScreen = 3
}
declare enum TUICaptureSourceType {
    kWindow = 0,
    kScreen = 1
}
declare enum TUIChangeReason {
    kChangedBySelf = 0,
    kChangedByAdmin = 1
}
declare enum TUIKickedOutOfRoomReason {
    kKickedByAdmin = 0,
    kKickedByLoggedOnOtherDevice = 1,
    kKickedByServer = 2
}
declare enum TUIRequestAction {
    kInvalidAction = 0,
    kRequestToOpenRemoteCamera = 1,
    kRequestToOpenRemoteMicrophone = 2,
    kRequestToConnectOtherRoom = 3,
    kRequestToTakeSeat = 4,
    kRequestRemoteUserOnSeat = 5,
    kApplyToAdminToOpenLocalCamera = 6,
    kApplyToAdminToOpenLocalMicrophone = 7,
    kApplyToAdminToOpenLocalScreenShare = 8
}
declare enum TUIRequestCallbackType {
    kRequestAccepted = 0,
    kRequestRejected = 1,
    kRequestCancelled = 2,
    kRequestTimeout = 3,
    kRequestError = 4
}
declare enum TRTCRole {
    kAnchor = 0,
    kAudience = 1
}
declare enum TUIResolutionMode {
    kResolutionMode_Landscape = 0,
    kResolutionMode_Portrait = 1
}
declare enum TUIRoomDismissedReason {
    kByOwner = 1,
    kByServer = 2
}
type TUIUserInfo = {
    userId: string;
    userName: string;
    nameCard: string;
    avatarUrl: string;
    userRole: TUIRole;
    hasAudioStream: boolean;
    hasVideoStream: boolean;
    hasScreenStream: boolean;
    isMessageDisabled: boolean;
    roomCustomInfo: Record<string, any>;
};
type TUISeatInfo = {
    index: number;
    userId: string;
    userName: string;
    nameCard: string;
    avatarUrl: string;
    locked: boolean;
    isVideoLocked: boolean;
    isAudioLocked: boolean;
};
type TUIRequest = {
    requestAction: TUIRequestAction;
    timestamp: number;
    requestId: string;
    userId: string;
    userName: string;
    nameCard: string;
    avatarUrl: string;
    content: string;
};
type TUIRequestCallback = {
    requestCallbackType: TUIRequestCallbackType;
    requestId: string;
    userId: string;
    code: number;
    message: string;
};
declare enum TUIMediaDeviceType {
    kMediaDeviceTypeUnknown = -1,
    kMediaDeviceTypeAudioInput = 0,
    kMediaDeviceTypeAudioOutput = 1,
    kMediaDeviceTypeVideoCamera = 2
}
declare enum TUIMediaDeviceState {
    kMediaDeviceStateAdd = 0,
    kMediaDeviceStateRemove = 1,
    kMediaDeviceStateActive = 2
}
declare enum TUIAudioRoute {
    kAudioRouteSpeakerphone = 0,
    kAudioRouteEarpiece = 1
}
type TUIDeviceInfo = {
    deviceId: string;
    deviceName: string;
    deviceProperties?: {
        supportedResolution?: {
            width: number;
            height: number;
        }[];
    };
};
declare enum TUIConferenceStatus {
    kConferenceStatusNone = 0,
    kConferenceStatusNotStarted = 1,
    kConferenceStatusRunning = 2
}
declare enum TUIConferenceCancelReason {
    kConferenceCancelReasonCancelledByAdmin = 0,
    kConferenceCancelReasonRemovedFromAttendees = 1
}
type TUIConferenceInfo = {
    scheduleStartTime: number;
    scheduleEndTime: number;
    scheduleAttendees: string[];
    reminderSecondsBeforeStart: number;
    status: TUIConferenceStatus;
    basicRoomInfo: TUIRoomInfo;
};
type TUIConferenceModifyInfo = {
    scheduleStartTime?: number;
    scheduleEndTime?: number;
    basicRoomInfo: {
        roomId: string;
        roomName?: string;
    };
};
/**
 * 自动播放失败时回调参数结构体
 *
 * userId 用户ID
 * resume 恢复播放的回调函数
 */
type TUIAutoPlayCallbackInfo = {
    userId: string;
    resume: () => void;
};
declare enum TUIInvitationStatus {
    kNone = 0,
    kPending = 1,
    kTimeout = 2,
    kAccepted = 3,
    kRejected = 4
}
declare enum TUIInvitationCode {
    kSuccess = 0,
    kAlreadyInInvitationList = 1,
    kAlreadyInConference = 2
}
declare enum TUIInvitationRejectedReason {
    kRejectToEnter = 0,
    kInOtherConference = 1
}
type TUIInvitation = {
    status: TUIInvitationStatus;
    invitee: TUIUserInfo;
    inviter: TUIUserInfo;
};
/**
 * **TUIRoomEngine 事件列表**<br>
 * @namespace TUIRoomEvents
 * @example
 * import TUIRoomEngine, { TUIRoomEvents } from '@tencentcloud/tuiroom-engine-js';
 * const roomEngine = new TUIRoomEngine();
 * roomEngine.on(TUIRoomEvents.onError, (error) => {
 *  console.log('roomEngine.error', error);
 * })
 */
declare enum TUIRoomEvents {
    /**
     *
     * @description 错误事件
     * @event TUIRoomEvents#onError
     * @param {object} options
     * @param {number} options.code 错误代码
     * @param {string} options.message 错误信息
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onError, (error) => {
     *  console.log('TUIRoomError error', error);
     * })
     */
    onError = "onError",
    /**
     * @description 踢出房间事件
     * @default 'onKickedOutOfRoom'
     * @event TUIRoomEvents#onKickedOutOfRoom
     * @param {object} options
     * @param {string} options.roomId 房间号
     * @param {TUIKickedOutOfRoomReason} options.reason 用户被踢出房间枚举
     * @param {string} options.message 踢出房间信息
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onKickedOutOfRoom, ({ roomId, reason, message }) => {
     *   console.log('roomEngine.onKickedOutOfRoom', roomId, reason, message);
     * });
     */
    onKickedOutOfRoom = "onKickedOutOfRoom",
    /**
     * @description 当前用户被踢下线
     * @default 'onKickedOffLine'
     * @event TUIRoomEvents#onKickedOffLine
     * @param {string} options.message 用户被踢下线信息
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onKickedOffLine, ({ message }) => {
     *   console.log('roomEngine.onKickedOffLine', message);
     * });
     */
    onKickedOffLine = "onKickedOffLine",
    /**
     * @description userSig 过期事件
     * @default 'onUserSigExpired'
     * @event TUIRoomEvents#onUserSigExpired
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onUserSigExpired, () => {
     *   console.log('roomEngine.onUserSigExpired');
     * });
     */
    onUserSigExpired = "onUserSigExpired",
    /**
     * @description 主持人销毁房间事件
     * @default 'onRoomDismissed'
     * @event TUIRoomEvents#onRoomDismissed
     * @param {object} options
     * @param {string} options.roomId 房间号
     * @param {TUIRoomDismissedReason} options.reason 房间解散原因枚举，该字段自 v2.3.0 开始支持
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onRoomDismissed, ({ roomId,reason }) => {
     *   console.log('roomEngine.onRoomDismissed', roomId,reason);
     * });
     */
    onRoomDismissed = "onRoomDismissed",
    /**
     * @description 房间名字修改事件
     * @default 'onRoomNameChanged'
     * @event TUIRoomEvents#onRoomChanged
     * @param {object} options
     * @param {string} options.roomName 房间名字
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onRoomNameChanged, ({ roomId, roomName }) =>{
     *    console.log('roomEngine.onRoomNameChanged', roomId, roomName);
     * });
     */
    onRoomNameChanged = "onRoomNameChanged",
    /**
     * @description 上麦模式修改事件
     * @default 'onRoomSeatModeChanged'
     * @event TUIRoomEvents#onRoomSeatModeChanged
     * @param {object} options
     * @param {TUISeatMode} options.seatMode 房间上麦模式
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onRoomSeatModeChanged, ({ roomId, seatMode }) =>{
     *    console.log('roomEngine.onRoomSeatModeChanged', roomId, seatMode);
     * });
     */
    onRoomSeatModeChanged = "onRoomSeatModeChanged",
    /**
     * @description 房间内人数变化事件
     * @default 'onRoomUserCountChanged'
     * @event TUIRoomEvents#onRoomUserCountChanged
     * @param {object} options
     * @param {string} options.roomId 房间号
     * @param {number} options.userCount 房间内人数
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onRoomUserCountChanged, ({ roomId, userCount }) =>{
     *    console.log('roomEngine.onRoomUserCountChanged', roomId, userCount);
     * });
     */
    onRoomUserCountChanged = "onRoomUserCountChanged",
    /**
     * @description 所有成员摄像头使用权限改变事件
     * @default 'onAllUserCameraDisableChanged'
     * @event TUIRoomEvents#onAllUserCameraDisableChanged
     * @param {object} options
     * @param {boolean} options.isDisable 是否允许使用摄像头
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onAllUserCameraDisableChanged, ({ isDisable }) =>{
     *    console.log('roomEngine.onAllUserCameraDisableChanged', isDisable);
     * });
     */
    onAllUserCameraDisableChanged = "onAllUserCameraDisableChanged",
    /**
     * @since v2.2.0
     * @description 房间内所有用户屏幕分享被禁用事件
     * @default 'onScreenShareForAllUserDisableChanged'
     * @event TUIRoomEvents#onScreenShareForAllUserDisableChanged
     * @param {object} options
     * @param {boolean} options.isDisable 是否开启禁止屏幕分享
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onScreenShareForAllUserDisableChanged, ({ isDisable }) =>{
     *    console.log('roomEngine.onScreenShareForAllUserDisableChanged', isDisable);
     * });
     */
    onScreenShareForAllUserDisableChanged = "onScreenShareForAllUserDisableChanged",
    /**
     * @description 所有成员麦克风使用权限改变事件
     * @default 'onAllUserMicrophoneDisableChanged'
     * @event TUIRoomEvents#onAllUserMicrophoneDisableChanged
     * @param {object} options
     * @param {boolean} options.isDisable 是否允许使用麦克风
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onAllUserMicrophoneDisableChanged, ({ isDisable }) =>{
     *    console.log('roomEngine.onAllUserMicrophoneDisableChanged', isDisable);
     * });
     */
    onAllUserMicrophoneDisableChanged = "onAllUserMicrophoneDisableChanged",
    /**
     * @description 所有成员发送消息权限改变事件
     * @default 'onSendMessageForAllUserDisableChanged'
     * @event TUIRoomEvents#OnSendMessageForAllUserDisableChanged
     * @param {object} options
     * @param {boolean} options.isDisable 是否被允许
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onSendMessageForAllUserDisableChanged, ({ isDisable }) =>{
     *    console.log('roomEngine.onSendMessageForAllUserDisableChanged', isDisable);
     * });
     */
    onSendMessageForAllUserDisableChanged = "onSendMessageForAllUserDisableChanged",
    /**
     * @description 房间最大麦位数修改事件
     * @default 'onRoomMaxSeatCountChanged'
     * @event TUIRoomEvents#onRoomMaxSeatCountChanged
     * @param {object} options
     * @param {boolean} options.maxSeatNumber 最大麦位数
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onRoomMaxSeatCountChanged, ({ maxSeatNumber }) =>{
     *    console.log('roomEngine.onRoomMaxSeatCountChanged', maxSeatNumber);
     * });
     */
    onRoomMaxSeatCountChanged = "onRoomMaxSeatCountChanged",
    /**
     * @description 远端用户进入房间事件
     * @default 'onRemoteUserEnterRoom'
     * @event TUIRoomEvents#onRemoteUserEnterRoom
     * @param {object} options
     * @param {string} options.roomId 房间号
     * @param {TUIUserInfo} options.userInfo 用户信息
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onRemoteUserEnterRoom, ({ roomId, userInfo }) => {
     *   console.log('roomEngine.onRemoteUserEnterRoom', roomId, userInfo);
     * });
     */
    onRemoteUserEnterRoom = "onRemoteUserEnterRoom",
    /**
     * @description 远端用户离开房间事件
     * @default 'onRemoteUserLeaveRoom'
     * @event TUIRoomEvents#onRemoteUserLeaveRoom
     * @param {object} options
     * @param {string} options.roomId 房间号
     * @param {TUIUserInfo} options.userInfo 用户信息
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onRemoteUserLeaveRoom, ({ roomId, userInfo }) => {
     *   console.log('roomEngine.onRemoteUserLeaveRoom', roomId, userInfo);
     * });
     */
    onRemoteUserLeaveRoom = "onRemoteUserLeaveRoom",
    /**
     * @since v2.5.0
     * @description 房间内用户信息改变事件
     * @default 'onUserInfoChanged'
     * @event TUIRoomEvents#onUserInfoChanged
     * @param {object} options
     * @param {TUIUserInfo} options.userInfo 用户信息
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onUserInfoChanged, ({ userInfo }) => {
     *   console.log('roomEngine.onUserInfoChanged', userInfo);
     * });
     */
    onUserInfoChanged = "onUserInfoChanged",
    /**
     * @description 用户角色改变事件
     * @deprecated 该接口自 v2.5.0 版本废弃，请使用'onUserInfoChanged'.
     * @default 'onUserRoleChanged'
     * @event TUIRoomEvents#onUserRoleChanged
     * @param {object} options
     * @param {string} options.userId 用户Id
     * @param {TUIRole} options.userRole 用户变更后的角色
     * @param {TUIUserInfo} options.userInfo 用户信息,该字段自 v2.3.0 开始支持
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onUserRoleChanged, ({ userInfo }) => {
     *   console.log('roomEngine.onUserRoleChanged', userInfo);
     * });
     */
    onUserRoleChanged = "onUserRoleChanged",
    /**
     * @description 用户视频状态改变事件
     * @default 'onUserVideoStateChanged'
     * @event TUIRoomEvents#onUserVideoStateChanged
     * @param {object} options
     * @param {string} options.userId 用户Id
     * @param {TUIVideoStreamType} options.streamType 用户流类型
     * @param {boolean} options.hasVideo 是否有视频流
     * @param {TUIChangeReason} options.reason 变更原因
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onUserVideoStateChanged, ({ userId, streamType, hasVideo, reason }) => {
     *   console.log('roomEngine.onUserVideoStateChanged', userId, streamType, hasVideo, reason);
     * });
     */
    onUserVideoStateChanged = "onUserVideoStateChanged",
    /**
     * @description 用户音频状态改变事件
     * @default 'onUserAudioStateChanged'
     * @event TUIRoomEvents#onUserAudioStateChanged
     * @param {object} options
     * @param {string} options.userId 用户Id
     * @param {boolean} options.hasVideo 是否有音频流
     * @param {TUIChangeReason} options.reason 原因
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onUserAudioStateChanged, ({ userId, hasAudio, reason }) => {
     *   console.log('roomEngine.onUserAudioStateChanged', userId, hasAudio, reason);
     * });
     */
    onUserAudioStateChanged = "onUserAudioStateChanged",
    /**
     * @description 用户发送消息状态改变事件
     * @default 'onSendMessageForUserDisableChanged'
     * @event TUIRoomEvents#onSendMessageForUserDisableChanged
     * @param {object} options
     * @param {string} options.userId 成员 Id
     * @param {boolean} options.isDisable 是否被允许
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onSendMessageForUserDisableChanged, ({ userId, isDisable }) =>{
     *    console.log('roomEngine.onSendMessageForUserDisableChanged', isDisable);
     * });
     */
    onSendMessageForUserDisableChanged = "onSendMessageForUserDisableChanged",
    /**
     * @description 用户音量改变事件
     * @default 'onUserVoiceVolumeChanged'
     * @event TUIRoomEvents#onUserVoiceVolumeChanged
     * @param {object} options
     * @param {Array<TRTCVolumeInfo>} options.userVolumeList 房间内所有用户的音量, 包含 userId 及 volume 信息，volume 区间为 1～100;
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onUserVoiceVolumeChanged, ({ userVolumeList }) => {
     *   userVolumeList.forEach(userVolume => {
     *     console.log('roomEngine.onUserVoiceVolumeChanged', userVolume.userId, userVolume.volume);
     *   })
     * });
     */
    onUserVoiceVolumeChanged = "onUserVoiceVolumeChanged",
    /**
     * @description 用户网络质量改变事件
     * @default 'onUserNetworkQualityChanged'
     * @event TUIRoomEvents#onUserNetworkQualityChanged
     * @param {object} options
     * @param {TUINetwork} options.userNetworkList 网络质量信息
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onUserNetworkQualityChanged, ({ userNetworkList }) => {
     *   userNetworkList.forEach(userNetwork => {
     *     console.log('roomEngine.onUserNetworkQualityChanged',
     *        userNetwork.userId, userNetwork.quality, userNetwork.upLoss, userNetwork.downLoss, userNetwork.delay);
     *   })
     * });
     */
    onUserNetworkQualityChanged = "onUserNetworkQualityChanged",
    /**
     * @description 麦位列表改变事件
     * @default 'onSeatListChanged'
     * @event TUIRoomEvents#onSeatListChanged
     * @param {object} options
     * @param {Array<TUISeatInfo>} options.seatList 麦位列表
     * @param {Array<TUISeatInfo>} options.seatedList 新增麦位列表
     * @param {Array<TUISeatInfo>} options.leftList 离开的麦位列表
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onSeatListChanged, ({ seatList, seatedList, leftList }) => {
     *   console.log('roomEngine.onSeatListChanged',seatList, seatedList, leftList);
     * });
     */
    onSeatListChanged = "onSeatListChanged",
    /**
     * @description 当前用户被踢下麦事件
     * @default 'onKickedOffSeat'
     * @event TUIRoomEvents#onKickedOffSeat
     * @param {number} options.seatIndex 麦位编号，该字段自 v2.3.0 开始支持
     * @param {TUIUserInfo} options.userInfo 操作踢人的（主持人/管理员）用户信息，该字段自 v2.3.0 开始支持
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onKickedOffSeat, ({ seatIndex, userInfo }) => {
     *   console.log('roomEngine.onKickedOffSeat', seatIndex, userInfo);
     * });
     */
    onKickedOffSeat = "onKickedOffSeat",
    /**
     * @description 请求接收事件
     * @default 'onRequestReceived'
     * @event TUIRoomEvents#onRequestReceived
     * @param {object} options
     * @param {TUIRequest} options.request 请求接收
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onRequestReceived, ({ request }) => {
     *   console.log('roomEngine.onRequestReceived', request);
     * });
     */
    onRequestReceived = "onRequestReceived",
    /**
     * @description 请求取消事件
     * @default 'onRequestCancelled'
     * @event TUIRoomEvents#onRequestCancelled
     * @param {object} options
     * @param {string} options.requestId 请求Id
     * @param {string} options.userId 取消请求的用户Id
     * @param {TUIRequest} options.request 请求信息，该字段自 v2.3.0 开始支持
     * @param {TUIUserInfo} options.userInfo 处理该请求的 管理员/房主 的用户信息，该字段自 v2.3.0 开始支持
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onRequestCancelled, ({ request, userInfo }) => {
     *   console.log('roomEngine.onRequestCancelled', request, userInfo);
     * });
     */
    onRequestCancelled = "onRequestCancelled",
    /**
     * @description 请求被其他 管理员/房主 处理事件
     * @default 'onRequestProcessed'
     * @event TUIRoomEvents#onRequestProcessed
     * @param {object} options
     * @param {string} options.requestId 请求Id
     * @param {string} options.userId 处理该请求的 管理员/房主 的用户ID
     * @param {TUIRequest} options.request 请求信息，该字段自 v2.3.0 开始支持
     * @param {TUIUserInfo} options.userInfo 处理该请求的 管理员/房主 的用户信息，该字段自 v2.3.0 开始支持
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onRequestProcessed, ({ request, userInfo }) => {
     *   console.log('roomEngine.onRequestProcessed', request, userInfo);
     * });
     */
    onRequestProcessed = "onRequestProcessed",
    /**
     * @description 接收文本消息事件
     * @deprecated 该接口自 v2.0.0 版本废弃，请使用 tim 实例监听收消息事件
     * @default 'onReceiveTextMessage'
     * @event TUIRoomEvents#onReceiveTextMessage
     * @param {object} options
     * @param {string} options.roomId 房间Id
     * @param {TUIMessage} options.message 接收的文本消息
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onReceiveTextMessage, ({ roomId, message }) => {
     *   console.log('roomEngine.onReceiveTextMessage', roomId, message);
     * });
     */
    onReceiveTextMessage = "onReceiveTextMessage",
    /**
     * @description 接收自定义消息事件
     * @deprecated 该接口自 v2.0.0 版本废弃，请使用 tim 实例监听收消息事件
     * @default 'onReceiveCustomMessage'
     * @event TUIRoomEvents#onReceiveCustomMessage
     * @param {object} options
     * @param {string} options.roomId 房间Id
     * @param {TUIMessage} options.message 接收的自定义消息
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onReceiveCustomMessage, ({ roomId, message }) => {
     *   console.log('roomEngine.onReceiveCustomMessage', roomId, message);
     * });
     */
    onReceiveCustomMessage = "onReceiveCustomMessage",
    /**
     * @description 设备变更事件
     * @default 'onDeviceChange'
     * @event TUIRoomEvents#onDeviceChange
     * @param {object} options
     * @param {string} options.deviceId 设备 Id
     * @param {TRTCDeviceType} options.type 设备类型
     * @param {TRTCDeviceState} options.state 设备变更状态
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onDeviceChange, ({ deviceId, type, state }) => {
     *   console.log('roomEngine.onDeviceChange', deviceId, type, state);
     * });
     */
    onDeviceChange = "onDeviceChange",
    /**
     * @description 屏幕分享停止事件，当用户使用浏览器自带的【停止分享】按钮结束屏幕共享时，该用户会收到 'onUserScreenCaptureStopped' 事件用来修改屏幕共享状态。
     * @default 'onUserScreenCaptureStopped'
     * @event TUIRoomEvents#onUserScreenCaptureStopped
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onUserScreenCaptureStopped, () => {
     *   console.log('roomEngine.onUserScreenCaptureStopped');
     * });
     */
    onUserScreenCaptureStopped = "onUserScreenCaptureStopped",
    /**
     * @description 自动播放失败的事件，监听到该事件后可以引导用户与页面进行交互
     * @default 'onAutoPlayFailed'
     * @event TUIRoomEvents#onAutoPlayFailed
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(TUIRoomEvents.onAutoPlayFailed, ({userId, resume}) => {
     *   // 自动播放失败，引导用户与页面进行交互
     * });
     */
    onAutoPlayFailed = "onAutoPlayFailed"
}
declare enum TUIRoomDeviceMangerEvents {
    /**
     * @description 设备变更事件
     * @default 'onDeviceChange'
     * @event TUIRoomDeviceMangerEvents#onDeviceChange
     * @param {object} options
     * @param {string} options.deviceId 设备 Id
     * @param {TRTCDeviceType} options.type 设备类型
     * @param {TRTCDeviceState} options.state 设备变更状态
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const deviceManager = roomEngine.getDeviceManager();
     * deviceManager.on(TUIRoomDeviceMangerEvents.onDeviceChange, ({ deviceId, type, state }) => {
     *   console.log('deviceManager.onDeviceChange', deviceId, type, state);
     * });
     */
    onDeviceChanged = "onDeviceChanged",
    /**
     * @description 麦克风测试音量
     * @default 'onTestMicVolume'
     * @event TUIRoomDeviceMangerEvents#onTestMicVolume
     * @param {object} options
     * @param {number} options.volume 麦克风测试音量（0-100）
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const deviceManager = roomEngine.getDeviceManager();
     * deviceManager.on(TUIRoomDeviceMangerEvents.onTestMicVolume, ({ volume }) => {
     *   console.log('deviceManager.onTestMicVolume', volume);
     * });
     */
    onTestMicVolume = "onTestMicVolume",
    /**
     * @description 扬声器测试音量，仅 Electron 端支持
     * @default 'onTestSpeakerVolume'
     * @event TUIRoomDeviceMangerEvents#onTestSpeakerVolume
     * @param {object} options
     * @param {number} options.volume 扬声器测试音量（0-100）
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const deviceManager = roomEngine.getDeviceManager();
     * deviceManager.on(TUIRoomDeviceMangerEvents.onTestSpeakerVolume, ({ volume }) => {
     *   console.log('deviceManager.onTestSpeakerVolume', volume);
     * });
     */
    onTestSpeakerVolume = "onTestSpeakerVolume"
}
/**
 * @since v2.5.0
 * **TUIConferenceListManager 事件列表**<br>
 * @namespace TUIConferenceListManagerEvents
 */
declare enum TUIConferenceListManagerEvents {
    /**
     * @description 会议预定回调
     * @default 'onConferenceScheduled'
     * @event TUIConferenceListManagerEvents#onConferenceScheduled
     * @param {object} options
     * @param {string} options.conferenceInfo 会议信息。
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceListManager = roomEngine.getConferenceListManager();
     * conferenceListManager.on(TUIConferenceListManagerEvents.onConferenceScheduled, ({ conferenceInfo }) => {
     *  console.log('conferenceListManager.onConferenceScheduled', conferenceInfo);
     * })
     */
    onConferenceScheduled = "onConferenceScheduled",
    /**
     * @description 会议即将开始回调
     * @default 'onConferenceWillStart'
     * @event TUIConferenceListManagerEvents#onConferenceWillStart
     * @param {object} options
     * @param {string} options.conferenceInfo 会议信息。
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceListManager = roomEngine.getConferenceListManager();
     * conferenceListManager.on(TUIConferenceListManagerEvents.onConferenceWillStart, ({ conferenceInfo }) => {
     *  console.log('conferenceListManager.onConferenceWillStart', conferenceInfo);
     * })
     */
    onConferenceWillStart = "onConferenceWillStart",
    /**
     * @description 会议取消回调
     *
     * @param {object} options
     * @param {string} options.roomId 会议Id，即房间 roomId 。
     * @param {TUIConferenceCancelReason} options.reason 会议取消原因。
     * @param {TUIUserInfo} options.operateUser 取消会议操作者信息。
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceListManager = roomEngine.getConferenceListManager();
     * conferenceListManager.on(TUIConferenceListManagerEvents.onConferenceCancelled, ({ roomId, reason, operateUser }) => {
     *  console.log('conferenceListManager.onConferenceCancelled', roomId, reason, operateUser);
     * })
     */
    onConferenceCancelled = "onConferenceCancelled",
    /**
     * @description 会议信息变更回调
     *
     * @param {object} options
     * @param {TUIConferenceModifyInfo} options.conferenceModifyInfo 会议信息。
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceListManager = roomEngine.getConferenceListManager();
     * conferenceListManager.on(TUIConferenceListManagerEvents.onConferenceInfoChanged, ({ conferenceModifyInfo }) => {
     *  console.log('conferenceListManager.onConferenceInfoChanged', conferenceModifyInfo);
     * })
     */
    onConferenceInfoChanged = "onConferenceInfoChanged",
    /**
     * @description 参会人员变更回调
     *
     * @param {object} options
     * @param {string} options.roomId 会议Id，即房间roomId。
     * @param {Array<TUIUserInfo>} options.leftUsers 离开成员列表。
     * @param {Array<TUIUserInfo>} options.joinedUsers 新加入成员列表。
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceListManager = roomEngine.getConferenceListManager();
     * conferenceListManager.on(TUIConferenceListManagerEvents.onScheduleAttendeesChanged, ({ roomId, leftUsers, joinedUsers }) => {
     *  console.log('conferenceListManager.onScheduleAttendeesChanged', roomId, leftUsers, joinedUsers);
     * })
     */
    onScheduleAttendeesChanged = "onScheduleAttendeesChanged",
    /**
     * @description 会议状态变更回调
     *
     * @param {object} options
     * @param {string} options.roomId 会议Id，即房间roomId。
     * @param {TUIConferenceStatus} options.status 会议状态。
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceListManager = roomEngine.getConferenceListManager();
     * conferenceListManager.on(TUIConferenceListManagerEvents.onConferenceStatusChanged, ({ roomId, status }) => {
     *  console.log('conferenceListManager.onConferenceStatusChanged', roomId, status );
     * })
     */
    onConferenceStatusChanged = "onConferenceStatusChanged"
}
/**
 * @since v2.6.0
 * **TUIConferenceInvitationManager 事件列表**<br>
 * @namespace TUIConferenceInvitationManagerEvents
 */
declare enum TUIConferenceInvitationManagerEvents {
    /**
     * @description 收到会中邀请回调
     * @default 'onReceiveInvitation'
     * @event TUIConferenceInvitationManagerEvents#onReceiveInvitation
     * @param {object} options
     * @param {TUIRoomInfo} options.roomInfo 会议信息。
     * @param {TUIInvitation} options.invitation 邀请信息。
     * @param {string} options.extensionInfo 自定义扩展信息
     *
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * conferenceInvitationManager.on(TUIConferenceInvitationManagerEvents.onReceiveInvitation, ({ roomInfo, invitation, extensionInfo }) => {
     *  console.log('conferenceInvitationManager.onReceiveInvitation', roomInfo, invitation, extensionInfo);
     * })
     */
    onReceiveInvitation = "onReceiveInvitation",
    /**
     * @description 邀请在其他设备处理的回调
     * @default 'onInvitationHandledByOtherDevice'
     * @event TUIConferenceInvitationManagerEvents#onInvitationHandledByOtherDevice
     * @param {object} options
     * @param {TUIRoomInfo} options.roomInfo 会议信息。
     * @param {boolean} options.accepted 接受状态。
     *
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * conferenceInvitationManager.on(TUIConferenceInvitationManagerEvents.onInvitationHandledByOtherDevice, ({ roomInfo, accepted }) => {
     *  console.log('conferenceInvitationManager.onInvitationHandledByOtherDevice', roomInfo, accepted);
     * })
     */
    onInvitationHandledByOtherDevice = "onInvitationHandledByOtherDevice",
    /**
     * @description 会中邀请取消的回调
     * @default 'onInvitationCancelled'
     * @event TUIConferenceInvitationManagerEvents#onInvitationCancelled
     * @param {object} options
     * @param {TUIRoomInfo} options.roomInfo 会议信息。
     * @param {TUIInvitation} options.invitation 邀请信息。
     *
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * conferenceInvitationManager.on(TUIConferenceInvitationManagerEvents.onInvitationCancelled, ({ roomInfo, invitation }) => {
     *  console.log('conferenceInvitationManager.onInvitationCancelled', roomInfo, invitation);
     * })
     */
    onInvitationCancelled = "onInvitationCancelled",
    /**
     * @description 会中邀请接受的回调
     * @default 'onInvitationAccepted'
     * @event TUIConferenceInvitationManagerEvents#onInvitationAccepted
     * @param {object} options
     * @param {TUIRoomInfo} options.roomInfo 会议信息。
     * @param {TUIInvitation} options.invitation 邀请信息。
     *
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * conferenceInvitationManager.on(TUIConferenceInvitationManagerEvents.onInvitationAccepted, ({ roomInfo, invitation }) => {
     *  console.log('conferenceInvitationManager.onInvitationAccepted', roomInfo, invitation);
     * })
     */
    onInvitationAccepted = "onInvitationAccepted",
    /**
     * @description 会中邀请拒绝的回调
     * @default 'onInvitationRejected'
     * @event TUIConferenceInvitationManagerEvents#onInvitationRejected
     * @param {object} options
     * @param {TUIRoomInfo} options.roomInfo 会议信息。
     * @param {TUIInvitation} options.invitation 邀请信息。
     * @param {TUIInvitationRejectedReason} options.reason 拒绝加入会议的原因。
     *
     *
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * conferenceInvitationManager.on(TUIConferenceInvitationManagerEvents.onInvitationRejected, ({ roomInfo, invitation, reason }) => {
     *  console.log('conferenceInvitationManager.onInvitationRejected', roomInfo, invitation, reason);
     * })
     */
    onInvitationRejected = "onInvitationRejected",
    /**
     * @description 会中邀请超时的回调
     * @default 'onInvitationTimeout'
     * @event TUIConferenceInvitationManagerEvents#onInvitationTimeout
     * @param {object} options
     * @param {TUIRoomInfo} options.roomInfo 会议信息。
     * @param {TUIInvitation} options.invitation 邀请信息。
     *
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * conferenceInvitationManager.on(TUIConferenceInvitationManagerEvents.onInvitationTimeout, ({ roomInfo, invitation }) => {
     *  console.log('conferenceInvitationManager.onInvitationTimeout', roomInfo, invitation);
     * })
     */
    onInvitationTimeout = "onInvitationTimeout",
    /**
     * @description 会中邀请被管理员撤回的回调
     * @default 'onInvitationRevokedByAdmin'
     * @event TUIConferenceInvitationManagerEvents#onInvitationRevokedByAdmin
     * @param {object} options
     * @param {TUIRoomInfo} options.roomInfo 会议信息。
     * @param {TUIInvitation} options.invitation 邀请信息。
     * @param {TUIUserInfo} options.operateUser 撤回邀请的人的信息
     *
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * conferenceInvitationManager.on(TUIConferenceInvitationManagerEvents.onInvitationRevokedByAdmin, ({ roomInfo, invitation, userRole }) => {
     *  console.log('conferenceInvitationManager.onInvitationRevokedByAdmin', roomInfo, invitation, operateUser);
     * })
     */
    onInvitationRevokedByAdmin = "onInvitationRevokedByAdmin",
    /**
     * @description 新添加会中邀请的回调
     * @default 'onInvitationAdded'
     * @event TUIConferenceInvitationManagerEvents#onInvitationAdded
     * @param {object} options
     * @param {TUIRoomInfo} options.roomInfo 会议信息。
     * @param {TUIInvitation} options.invitation 邀请信息。
     *
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * conferenceInvitationManager.on(TUIConferenceInvitationManagerEvents.onInvitationAdded, ({ roomInfo, invitation }) => {
     *  console.log('conferenceInvitationManager.onInvitationAdded', roomInfo, invitation);
     * })
     */
    onInvitationAdded = "onInvitationAdded",
    /**
     * @description 会中邀请被移除的回调
     * @default 'onInvitationRemoved'
     * @event TUIConferenceInvitationManagerEvents#onInvitationRemoved
     * @param {object} options
     * @param {TUIRoomInfo} options.roomInfo 会议信息。
     * @param {TUIInvitation} options.invitation 邀请信息。
     *
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * conferenceInvitationManager.on(TUIConferenceInvitationManagerEvents.onInvitationRemoved, ({ roomInfo, invitation }) => {
     *  console.log('conferenceInvitationManager.onInvitationRemoved', roomInfo, invitation);
     * })
     */
    onInvitationRemoved = "onInvitationRemoved",
    /**
     * @description 会中邀请状态变更的回调
     * @default 'onInvitationStatusChanged'
     * @event TUIConferenceInvitationManagerEvents#onInvitationStatusChanged
     * @param {object} options
     * @param {TUIRoomInfo} options.roomInfo 会议信息。
     * @param {TUIInvitation} options.invitation 邀请信息。
     *
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * conferenceInvitationManager.on(TUIConferenceInvitationManagerEvents.onInvitationStatusChanged, ({ roomInfo, invitation }) => {
     *  console.log('conferenceInvitationManager.onInvitationStatusChanged', roomInfo, invitation);
     * })
     */
    onInvitationStatusChanged = "onInvitationStatusChanged"
}
type TUILiveInfo = {
    basicRoomInfo: TUIRoomInfo;
    isGiftEnabled: boolean;
    isLikeEnabled: boolean;
    isPublicVisible: boolean;
    activityStatus: number;
    viewCount: number;
    coverUrl: string;
    backgroundUrl: string;
    categoryList: Array<number>;
};
type TUILiveModifyInfo = {
    roomId: string;
    isPublicVisible?: boolean;
    activityStatus?: number;
    coverUrl?: string;
    backgroundUrl?: string;
    categoryList?: Array<number>;
};
declare enum TUILiveModifyFlag {
    kNone = 0,
    kActivityStatus = 256,
    kCoverUrl = 512,
    kCategory = 1024,
    kEnableGift = 2048,
    kEnableLike = 4096,
    kPublic = 8192,
    kBackgroundUrl = 262144
}
type TUILiveListResult = {
    cursor: string;
    listInfoList: Array<TUILiveInfo>;
};
/**
 * @since v2.9.0
 * ** TUILiveListManager 事件列表**<br>
 */
declare enum TUILiveListManagerEvents {
    /**
     * @description 直播间信息发生变化事件回调
     * @default 'onLiveInfoChanged'
     * @event TUILiveListManagerEvents#onLiveInfoChanged
     * @param {object} options
     * @param {TUILiveInfo} options.liveInfo 直播间信息
     * @param {TUILiveModifyFlag} options.modifyFlag 直播间修改标识
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const liveListManager = roomEngine.getLiveListManager();
     * liveListManager.on(TUILiveListManagerEvents.onLiveInfoChanged, ({ liveInfo, modifyFlag}) => {
     *   console.log('liveListManager.onLiveInfoChanged', liveInfo, modifyFlag);
     * });
     */
    onLiveInfoChanged = "onLiveInfoChanged"
}
declare enum TUILiveLayoutManagerEvents {
    /**
     * const roomEngine = new TUIRoomEngine();
     * const liveLayoutManager = roomEngine.getLiveLayoutManager();
     * const callback = (roomId, layoutInfo) => {
     *   console.log('liveLayoutManager.onLiveVideoLayoutChanged', roomId, layoutInfo);
     * };
     * liveLayoutManager.on(TUILiveLayoutManagerEvents.onLiveVideoLayoutChanged, callback);
     */
    onLiveVideoLayoutChanged = "onLiveVideoLayoutChanged"
}

declare class Logger {
    private logger;
    private trtcCloud;
    private seq;
    constructor(trtcCloud: any, options?: {
        userId: string;
        sdkAppId: number;
        seq: number;
    });
    getLogMessage(params: any[]): string | any[];
    update(options: {
        sdkAppId: number;
        userId: string;
    }): void;
    debug(...params: any[]): void;
    info(...params: any[]): void;
    warn(...params: any[]): void;
    error(...params: any[]): void;
    private getTime;
}

/**
 * 设备管理
 * @class DeviceManager
 */
declare class TUIRoomDeviceManager {
    private deviceManagerWASM;
    private logger;
    private static deviceManager;
    private trtcCloud;
    constructor(options: {
        Module: any;
        logger: Logger;
        trtcCloud: TRTCCloud;
    });
    setDeviceManagerWASM(deviceManagerWASM: any): void;
    /**
     * @private
     * 调用 TUIRoomEngineWASM 的异步方法
     * @param funcName
     * @param args
     */
    private JSCallNativeFunctionPromise;
    /**
     * 获取设备列表
     * @param {TRTCDeviceType} type 设备类型
     * @example
     * // 获取设备管理 Manager
     * const roomEngine = new TUIRoomEngine();
     * const deviceManager = roomEngine.getDeviceManager();
     *
     * // 获取摄像头设备列表
     * const cameraList = await deviceManager.getDeviceList({ type: TUIMediaDeviceType.kMediaDeviceVideoCamera });
     * // 获取麦克风设备列表
     * const micList = await deviceManager.getDeviceList({ type: TUIMediaDeviceType.kMediaDeviceTypeAudioInput });
     * // 获取扬声器设备列表
     * const speakerList = await deviceManager.getDeviceList({ type: TUIMediaDeviceType.kMediaDeviceTypeAudioOutput });
     * @returns {Promise} Array<TUIDeviceInfo>
     */
    getDevicesList(options: {
        type: TUIMediaDeviceType;
    }): Promise<TUIDeviceInfo[]>;
    /**
     * 设置当前使用设备
     * @param {TRTCDeviceType} type 设备类型
     * @param {string} deviceId 设备 Id
     * @example
     * // 获取设备管理 Manager
     * const roomEngine = new TUIRoomEngine();
     * const deviceManager = roomEngine.getDeviceManager();
     *
     * // 设置当前麦克风设备
     * deviceManager.setCurrentDevice({
     *  type: TUIMediaDeviceType.kMediaDeviceTypeAudioInput,
     *  deviceId: 'default',
     * });
     * // 设置当前扬声器设备
     * deviceManager.setCurrentDevice({
     *  type: TUIMediaDeviceType.kMediaDeviceTypeAudioOutput,
     *  deviceId: 'default',
     * });
     * // 设置当前摄像头设备
     * deviceManager.setCurrentDevice({
     *  type: TUIMediaDeviceType.kMediaDeviceVideoCamera,
     *  deviceId: '',
     * });
     * @returns {void}
     */
    setCurrentDevice(options: {
        type: TUIMediaDeviceType;
        deviceId: string;
    }): Promise<void>;
    /**
     * 获取当前使用的设备信息
     * @param {object} options 获取当前设备信息的参数
     * @param {TUIMediaDeviceType} options.type 设备类型
     * @example
     * // 获取设备管理 Manager
     * const roomEngine = new TUIRoomEngine();
     * const deviceManager = roomEngine.getDeviceManager();
     * @returns {TUIDeviceInfo}
     */
    getCurrentDevice(options: {
        type: TUIMediaDeviceType;
    }): TUIDeviceInfo;
    /**
     * 开始进行摄像头测试
     * @param {object} options 摄像头测试参数
     * @param {string} options.view 显示摄像头测试的视频区域, 传入的 view 为承载预览画面 div 元素的 id
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.startCameraDeviceTest({ view: 'test-preview' });
     */
    startCameraDeviceTest(options: {
        view: string;
    }): Promise<void>;
    /**
     * 停止摄像头测试
     * @returns {Promise<void>}
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.stopCameraDeviceTest();
     */
    stopCameraDeviceTest(): Promise<void>;
    /**
     * 开始进行麦克风测试
     * @param options
     * @param {number} options.interval 麦克风音量的回调时间
     */
    startMicDeviceTest(options: {
        interval: number;
    }): Promise<void>;
    /**
     * 停止进行麦克风测试
     */
    stopMicDeviceTest(): Promise<void>;
    startSpeakerDeviceTest(options: {
        filePath: string;
    }): Promise<void>;
    stopSpeakerDeviceTest(): Promise<void>;
    isFrontCamera(): boolean;
    /**
     * 切换前后置摄像头，该接口只适用于移动端浏览器
     * @param {Object} options
     * @param {boolean} options.isFrontCamera 是否切换为前置摄像头
     *
     * const deviceManager = roomEngine.instance?.getDeviceManager();
     * // 移动端切换为前置摄像头
     * await deviceManager?.switchCamera({ isFrontCamera: true });
     * // 移动端切换为后置摄像头
     * await deviceManager?.switchCamera({ isFrontCamera: false });
     */
    switchCamera(options: {
        isFrontCamera: boolean;
    }): Promise<void>;
    isAutoFocusEnabled(): boolean;
    enableCameraTorch(options: {
        enabled: boolean;
    }): void;
    setAudioRoute(options: {
        route: TUIAudioRoute;
    }): void;
    /**
     * 监听 roomEngine 的事件
     * @param event TUIRoomEvents
     * @param func function
     * @returns {void}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const deviceManager = roomEngine.getDeviceManager();
     * deviceManager.on(event, func);
     */
    on(event: TUIRoomDeviceMangerEvents, func: (...args: any[]) => void): void;
    private handleTrtcCloudBindEvent;
    off(event: string, func: (...args: any[]) => void): void;
}

/**
 * 会议列表
 * @class conferenceListManager
 */
declare class TUIConferenceListManager {
    private static readonly ROOM_NAME;
    private static readonly SCHEDULED_START_TIME;
    private static readonly SCHEDULED_END_TIME;
    private conferenceListManagerWASM;
    private logger;
    private static conferenceListManager;
    constructor(options: {
        Module: any;
        logger: Logger;
        roomEngineWASM: any;
    });
    /**
     * @private
     * 调用 TUIRoomEngineWASM 的异步方法
     * @param funcName
     * @param args
     */
    private JSCallNativeFunctionPromise;
    /**
     * 预定会议
     * @param {object} options
     * @param {string} options.roomId 房间 Id，必填, roomId 限制长度为64字节，且仅支持以下范围的字符集：<br>
     * - 大小写英文字母（a-zA-Z）
     * - 数字（0-9）
     * - 空格 ! # $ % & ( ) + - : ; < = . > ? @ [ ] ^ _ { } | ~ ,
     * @param {number} [options.scheduleStartTime] 预定会议开始时间（计数单位为秒的时间戳）
     * @param {number} [options.scheduleEndTime] 预定会议结束时间（计数单位为秒的时间戳）
     * @param {array=} [options.scheduleAttendees=[]] 预定会议邀请成员 userId 列表
     * @param {number=} [options.reminderSecondsBeforeStart=0] 会议开始前提醒时间，单位秒
     * @param {string=} [options.roomName=roomId] 房间名称，默认值为 roomId，传入的值不能为空字符串
     * @param {TUIRoomType=} [options.roomType=TUIRoomType.kConference] 房间类型, 默认值为 TUIRoomType.kConference <br>
     * 办公协同、医疗问诊、远程会议、教育场景，roomType 设置为 TUIRoomType.kConference
     * 电商直播、语聊房场景，roomType 设置为 TUIRoomType.kLive
     * @param {boolean=} [options.isSeatEnabled=false] 是否开启麦位控制，默认值为 false
     * @param {TUISeatMode=} [options.seatMode=TUISeatMode.kFreeToTake] 上麦模式(开启麦位控制后生效)，默认值为 TUISeatMode.kFreeToTake <br>
     * 自由上麦模式，台下观众可以自由上麦，无需申请，seatMode 设置为 TUISeatMode.kFreeToTake
     * 申请上麦模式，台下观众上麦需要房主或者管理员同意后才能上麦，seatMode 设置为 TUISeatMode.kApplyToTake
     * @param {boolean=} [options.isMicrophoneDisableForAllUser=false] 是否开启全员禁麦，默认不开启全员禁麦（创建房间可选参数）
     * @param {boolean=} [options.isScreenShareDisableForAllUser=false] 是否开启禁止屏幕分享，默认不开启禁止屏幕分享权限（该属性自 v2.2.0 版本 以后支持，创建房间可选参数）
     * @param {boolean=} [options.isCameraDisableForAllUser=false] 是否开启全员禁画，默认不开启全员禁画（创建房间可选参数）
     * @param {boolean=} [options.isMessageDisableForAllUser=false] 是否允许成员发送消息，默认不禁止（创建房间可选参数）
     * @param {number=} options.maxSeatCount 最大麦位数量 （创建房间可选参数）
     * @param {string=} [options.password=''] 房间密码，（该属性自 v2.5.0 版本支持）
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceListManager = roomEngine.getConferenceListManager();
     * await conferenceListManager.scheduleConference({
     *  roomId: '12345', // 填入您的房间 Id, 注意房间 Id 要求为字符串类型
     *  scheduleStartTime: 1720004257, // 填入您的会议预定开始时间的时间戳，单位秒。
     *  scheduleEndTime: 1720001317, // 填入您的会议预定结束时间的时间戳，单位秒。
     * });
     */
    scheduleConference(options: {
        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;
    }): Promise<void>;
    /**
     * 取消预定会议
     *
     * @param {object} options
     * @param {string} options.roomId  要取消会议Id,即房间roomId。
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceListManager = roomEngine.getConferenceListManager();
     * await conferenceListManager.cancelConference({
     *  roomId: '12345',   // 填入您要取消的会议 Id ,即房间 roomId 。
     * });
     */
    cancelConference(options: {
        roomId: string;
    }): Promise<void>;
    /**
     * 更新预定会议信息
     *
     * @param {object} options
     * @param {string} options.roomId  会议的房间Id。
     * @param {string} options.roomName  会议的名称。
     * @param {number} options.scheduleStartTime  预定会议的开始时间（计数单位为秒的时间戳）。
     * @param {number} options.scheduleEndTime  预定会议的结束时间（计数单位为秒的时间戳）。
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceListManager = roomEngine.getConferenceListManager();
     * await conferenceListManager.updateConferenceInfo({
     *  roomId: '12345',   // 填入您要更新的会议房间 roomId 。
     *  roomName: 'myRoomName',  // 填入您更新后的会议名称。
     *  scheduleStartTime: 1720004257, // 填入您更新后的会议预定开始时间的时间戳，单位秒。
     *  scheduleEndTime: 1720001317, // 填入您更新后的会议预定结束时间的时间戳，单位秒。
     * });
     */
    updateConferenceInfo(options: {
        roomId: string;
        roomName?: string;
        scheduleStartTime?: number;
        scheduleEndTime?: number;
    }): Promise<void>;
    /**
     * 获取预定会议列表
     *
     * @param {object} options
     * @param {Array<TUIConferenceStatus>} options.statusArray 会议状态数组，默认值为拉取全部状态会议。
     * @param {string} options.cursor 分页获取索引，第一次拉取填 ''，回调成功 如果callback返回的数据中 cursor 不为 ''，表示需要分页，请以返回的 cursor 作为参数再次调用接口拉取，直至返回的cursor为 ''，表示数据已经全部拉取。
     * @param {number} options.count  本次拉取数量。
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceListManager = roomEngine.getConferenceListManager();
     * const conferenceList = [];
     * let result;
     * let cursor = '';
     * let count = 20;
     * do {
     *  result = await conferenceListManager.fetchScheduledConferenceList({ cursor, count });
     *  conferenceList.push(...result.conferenceList);
     *  cursor = result.cursor;
     * } while (cursor !== '')
     */
    fetchScheduledConferenceList(options: {
        statusArray?: TUIConferenceStatus[];
        cursor: string;
        count: number;
    }): Promise<Array<TUIConferenceInfo>>;
    /**
     * 获取预定会议邀请成员列表
     *
     * @param {object} options
     * @param {string} options.roomId  会议 Id ,即房间 roomId 。
     * @param {string} options.cursor 分页获取索引，第一次拉取填 ""，回调成功 如果 callback 返回的数据中 cursor 不为""，表示需要分页，请以返回的 cursor 作为参数再次调用接口拉取，直至返回的 cursor 为""，表示数据已经全部拉取。
     * @param {number} options.count  本次拉取数量。
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceListManager = roomEngine.getConferenceListManager();
     * const attendeeList = [];
     * let result;
     * let cursor = '';
     * let totalCount = 0;
     * let roomId = '12345';
     * let count = 20;
     * do {
     *  result = await conferenceListManager.fetchAttendeeList({ roomId, cursor, count });
     *  attendeeList.push(...result.attendeeList);
     *  cursor = result.cursor;
     *  totalCount = result.totalCount;
     * } while (cursor !== '')
     */
    fetchAttendeeList(options: {
        roomId: string;
        cursor: string;
        count: number;
    }): Promise<Array<TUIUserInfo>>;
    /**
     * 添加成员至邀请列表
     *
     * @param {object} options
     * @param {string} options.roomId  会议 Id ,即房间 roomId 。
     * @param {Array<string>} options.userIdList 成员 userId 列表。
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceListManager = roomEngine.getConferenceListManager();
     * await conferenceListManager.addAttendeesByAdmin({
     *  roomId: '12345',   // 填入您要添加成员的会议 Id ,即房间 roomId 。
     *  userIdList: ['123'],  // 填入您要邀请的成员 Id 数组。
     * });
     */
    addAttendeesByAdmin(options: {
        roomId: string;
        userIdList: string[];
    }): Promise<void>;
    /**
     * 从邀请列表移除成员
     *
     * @param {object} options
     * @param {string} options.roomId  会议 Id ,即房间 roomId 。
     * @param {Array<string>} options.userIdList 成员 userId 列表。
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceListManager = roomEngine.getConferenceListManager();
     * await conferenceListManager.removeAttendeesByAdmin({
     *  roomId: '12345',   // 填入您要移除成员的会议 Id ,即房间 roomId 。
     *  userIdList: ['123'],  // 填入您要移除的成员 Id 数组。
     * });
     */
    removeAttendeesByAdmin(options: {
        roomId: string;
        userIdList: string[];
    }): Promise<void>;
    /**
     * 监听 conferenceListManager 的事件
     * @param event TUIConferenceListManagerEvents
     * @param func function
     * @returns {void}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceListManager = roomEngine.getConferenceListManager();
     * conferenceListManager.on(event, func);
     */
    on(event: TUIConferenceListManagerEvents, func: (...args: any[]) => void): void;
    private observerFunction;
    private handleConferenceChangedEvent;
    /**
     * 取消监听  ConferenceListManager 的事件
     * @param event TUIConferenceListManagerEvents
     * @param func function
     * @returns {void}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceListManager = roomEngine.getConferenceListManager();
     * conferenceListManager.off(event, func);
     */
    off(event: string, func: (...args: any[]) => void): void;
}

/**
 * 会中呼叫
 * @class conferenceInvitationManager
 */
declare class TUIConferenceInvitationManager {
    private conferenceInvitationManagerWASM;
    private logger;
    private static conferenceInvitationManager;
    constructor(options: {
        Module: any;
        logger: Logger;
        roomEngineWASM: any;
    });
    /**
     * @private
     * 调用 TUIRoomEngineWASM 的异步方法
     * @param funcName
     * @param args
     */
    private JSCallNativeFunctionPromise;
    /**
     * 会中呼叫
     * @param {object} options
     * @param {string} options.roomId 房间 Id，必填, roomId 限制长度为64字节，且仅支持以下范围的字符集：<br>
     * - 大小写英文字母（a-zA-Z）
     * - 数字（0-9）
     * - 空格 ! # $ % & ( ) + - : ; < = . > ? @ [ ] ^ _ { } | ~ ,
     * @param {string} options.userIdList 成员 userId 列表。
     * @param {number} options.timeout 超时时间。若 timeout 设置为 0s ，则无超时时间
     * @param {string} options.extensionInfo 自定义扩展信息
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * await conferenceInvitationManager.inviteUsers({
     *  roomId: '12345', // 填入您的房间 Id, 注意房间 Id 要求为字符串类型
     *  userIdList: ['123'],  // 填入您要呼叫的成员 Id 数组。
     *  timeout: 0,
     * })
     */
    inviteUsers(options: {
        roomId: string;
        userIdList: string[];
        timeout: number;
        extensionInfo?: string;
    }): Promise<void>;
    /**
     * 取消呼叫
     *
     * @param {object} options
     * @param {string} options.roomId  会议的房间Id。
     * @param {string} options.userIdList 成员 userId 列表。
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * await conferenceInvitationManager.cancelInvitation({
     *  roomId: '12345', // 填入您的房间 Id, 注意房间 Id 要求为字符串类型
     *  userIdList: ['123'],  // 填入您要取消呼叫的成员 Id 数组。
     * })
     */
    cancelInvitation(options: {
        roomId: string;
        userIdList: string[];
    }): Promise<void>;
    /**
     * 接受呼叫
     *
     * @param {object} options
     * @param {string} options.roomId  会议的房间Id。
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * await conferenceInvitationManager.accept({
     *  roomId: '12345', // 填入您的房间 Id, 注意房间 Id 要求为字符串类型
     * })
     */
    accept(options: {
        roomId: string;
    }): Promise<void>;
    /**
     * 拒绝呼叫
     *
     * @param {object} options
     * @param {string} options.roomId  会议的房间Id。
     * @param {TUIInvitationRejectedReason}options.reason 拒绝邀请的原因
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * await conferenceInvitationManager.reject({
     *  roomId: '12345', // 填入您的房间 Id, 注意房间 Id 要求为字符串类型
     *  reason: TUIInvitationRejectedReason.kRejectToEnter, // 主动拒绝进入会议
     * })
     */
    reject(options: {
        roomId: string;
        reason: TUIInvitationRejectedReason;
    }): Promise<void>;
    /**
     * 获取呼叫列表
     *
     * @param {object} options
     * @param {string} options.roomId  会议的房间Id。
     * @param {string} options.cursor 分页获取索引，第一次拉取填 ""，回调成功 如果 callback 返回的数据中 cursor 不为""，表示需要分页，请以返回的 cursor 作为参数再次调用接口拉取，直至返回的 cursor 为""，表示数据已经全部拉取。
     * @param {string} options.count  本次拉取数量。
     * @returns {Promise<Array<TUIInvitation>>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * const invitationList = [];
     * let result;
     * let cursor = '';
     * let totalCount = 0;
     * let roomId = '12345';
     * let count = 20;
     * do {
     *  result = await conferenceInvitationManager.getInvitationList({ roomId, cursor, count });
     *  attendeeList.push(...result.attendeeList);
     *  cursor = result.cursor;
     *  totalCount = result.totalCount;
     * } while (cursor !== '')
     */
    getInvitationList(options: {
        roomId: string;
        cursor: string;
        count: number;
    }): Promise<Array<TUIInvitation>>;
    /**
     * 监听 conferenceInvitationManager 的事件
     * @param event TUIConferenceListManagerEvents
     * @param func function
     * @returns {void}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * conferenceInvitationManager.on(event, func);
     */
    on(event: TUIConferenceInvitationManagerEvents, func: (...args: any[]) => void): void;
    private observerFunction;
    /**
     * 取消监听  ConferenceInvitationManager 的事件
     * @param event TUIConferenceListManagerEvents
     * @param func function
     * @returns {void}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * conferenceInvitationManager.off(event, func);
     */
    off(event: string, func: (...args: any[]) => void): void;
}

/**
 * 直播列表
 * @class TUILiveListManager
 */
declare class TUILiveListManager {
    private liveListManagerWASM;
    private logger;
    private static liveListManager;
    constructor(options: {
        Module: any;
        logger: Logger;
        roomEngineWASM: any;
    });
    /**
     * 修改直播间信息
     *
     * @param {object} options
     * @param {string} options.roomId 直播房间 ID
     * @param {number} options.activityStatus 可选，直播间活跃状态: 用户自定义标记
     * @param {Array<number>} options.categoryList 可选，直播间分类标签，单个房间最大支持3个标记
     * @param {string} options.coverUrl 可选，直播间封面图片 HTTP URL 地址，最大支持 200 个字节
     * @param {string} options.backgroundUrl 可选，直播间背景图片 HTTP URL 地址，最大支持 200 个字节
     * @param {boolean} options.isPublicVisible 可选，直播间是否公开
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const liveListManager = roomEngine.getLiveListManager();
     * liveListManager.setLiveInfo({
     *   roomId: "141569",
     *   coverUrl: "https://qcloudimg.tencent-cloud.cn/image/document/live-cover.png",
     *   isPublicVisible: false,
     *   activityStatus: 1,
     *   categoryList: [1,2,3],
     *   backgroundUrl: "https://qcloudimg.tencent-cloud.cn/image/document/live-cover.png"
     * });
     */
    setLiveInfo(options: {
        roomId: string;
        activityStatus?: number;
        categoryList?: Array<number>;
        coverUrl?: string;
        isPublicVisible?: boolean;
        backgroundUrl?: string;
    }): Promise<void>;
    /**
     * 获取直播间信息
     *
     * @param {object} options
     * @param {string} options.roomId 直播房间 ID
     * @returns {Promise<TUILiveInfo>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const liveListManager = roomEngine.getLiveListManager();
     * const result = await liveListManager.getLiveInfo({ roomId: "141569" });
     */
    getLiveInfo(options: {
        roomId: string;
    }): Promise<TUILiveInfo>;
    /**
     * 获取直播间列表
     *
     * @param {object} options
     * @param {string} options.cursor 分页获取索引，第一次拉取填 ''，返回的数据中 cursor 不为 ''，表示需要分页，请以返回的 cursor 作为参数再次调用接口拉取，直至返回的cursor为 ''，表示数据已经全部拉取。
     * @param {number} options.count  本次拉取数量
     * @returns {Promise<TUILiveListResult>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const liveListManager = roomEngine.getLiveListManager();
     * const liveList = [];
     * let cursor = '';
     * let count = 20;
     * let result;
     * do {
     *   result = await liveListManager.fetchLiveList({ cursor, count });
     *   liveList.push(...result.liveInfoList);
     *   cursor = result.cursor;
     * } while(cursor !== '');
     */
    fetchLiveList(options: {
        cursor: string;
        count: number;
    }): Promise<TUILiveListResult>;
    private JSCallNativeFunctionPromise;
    /**
     * 监听 TUILiveListManager 事件
     * @param {TUILiveListManagerEvents} event - 事件名
     * @param {Function} func - 事件回调函数
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const liveListManager = roomEngine.getLiveListManager();
     * const callback = ({ liveModifyInfo }) => {
     *   console.log('liveListManager.onLiveInfoChanged', liveModifyInfo);
     * };
     * liveListManager.on(TUILiveListManagerEvents.onLiveInfoChanged, callback);
     */
    on(event: TUILiveListManagerEvents, func: (...args: any[]) => void): void;
    /**
     * 取消 TUILiveListManager 事件监听
     * @param {TUILiveListManagerEvents} event - 事件名
     * @param {Function} func - 事件回调函数
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const liveListManager = roomEngine.getLiveListManager();
     * const callback = ({ liveModifyInfo }) => {
     *   console.log('liveListManager.onLiveInfoChanged', liveModifyInfo);
     * };
     * liveListManager.off(TUILiveListManagerEvents.onLiveInfoChanged, callback);
     */
    off(event: TUILiveListManagerEvents, func: (...args: any[]) => void): void;
    private observerFunction;
    private handleLiveInfoChangeEvent;
}

/**
 * 直播自定义布局插件
 * @class TUILiveLayoutManager
 */
declare class TUILiveLayoutManager {
    private liveLayoutManagerWASM;
    private logger;
    private static liveLayoutManager;
    constructor(options: {
        Module: any;
        logger: Logger;
        roomEngineWASM: any;
    });
    private observerFunction;
    private handleLiveLayoutChangeEvent;
    private JSCallNativeFunctionPromise;
    /**
     * 监听 TUILiveLayoutManager 事件
     * @param {TUILiveLayoutManagerEvents} event 事件名
     * @param func 事件回调函数
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const liveLayoutManager = roomEngine.getLiveLayoutManager();
     * const callback = (roomId, layoutInfo) => {
     *   console.log('liveLayoutManager.onLiveVideoLayoutChanged', roomId, layoutInfo);
     * };
     * liveLayoutManager.on(TUILiveLayoutManagerEvents.onLiveVideoLayoutChanged, callback);
     */
    on(event: TUILiveLayoutManagerEvents, func: (...args: any[]) => void): void;
    /**
     * 取消 TUILiveLayoutManager 事件监听
     * @param {TUILiveLayoutManagerEvents} event 事件名
     * @param {Function} func 事件回调函数
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const liveLayoutManager = roomEngine.getLiveLayoutManager();
     * const callback = (roomId, layoutInfo) => {
     *   console.log('liveLayoutManager.onLiveVideoLayoutChanged', roomId, layoutInfo);
     * };
     * liveLayoutManager.off(TUILiveLayoutManagerEvents.onLiveVideoLayoutChanged, callback);
     */
    off(event: TUILiveLayoutManagerEvents, func: (...args: any[]) => void): void;
    /**
     * 设置自定义布局信息
     *
     * @param {string} roomId 直播房间 ID
     * @param {string} layoutInfo 自定义布局信息, 格式为 JSON 字符串
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const liveLayoutManager = roomEngine.getLiveLayoutManager();
     * liveLayoutManager.setLiveStreamLayoutInfo('roomId', '{
     *   // 设置画布大小
     *   "VideoEncode": {
     *     "Width": 1920,
     *     "Height": 1080,
     *   },
     *   "LayoutMode": 0, // 0~9 内置布局模板， 1000自定义布局， 只有1000时候才能修改LayoutInfo,目前只支持 0 和 1000
     *   // 设置画面布局
     *   "LayoutInfo": {
     *     "LayoutList": [
     *       {
     *         "LocationX": 0,                   // 以画面左上角为原点的 x 坐标
     *         "LocationY": 0,                   // 以画面左上角为原点的 y 坐标
     *         "ImageWidth": 1080,               // 调整后的画面宽度
     *         "ImageHeight": 960,               // 调整后的画面高度
     *         "ZOrder": 0,                      // 画面层级
     *         "StreamType": 0,                  // 0 摄像头, 1 屏幕共享, 2 白板, 3 自定义
     *         "Member_Account": "admin001",     // 该路流的用户ID
     *         "BackgroundImageUrl": "ImageUrl",
     *         "RoomId": "roomId",
     *         "BackgroundColor": "0x1F212C",
     *
     *       }
     *     ]
     *   },
     *   // 设置最大画面，只能有一路
     *   "MaxUserLayout": {
     *     "ZOrder": 0,        //层级
     *     "StreamType": 0,    // 0为摄像头， 1为屏幕共享
     *     "Member_Account": "admin001",
     *     "BackgroundImageUrl": "ImageUrl", //可以设置看看，可能在最大画面时候没作用
     *     "RoomId":"roomId",
     *     "BackgroundColor":"0x1F212C"
     *   }}');
     */
    setLiveStreamLayoutInfo(roomId: string, layoutInfo: string): Promise<void>;
}

/**
 * TUIRoomEngine 提供了音视频房间的能力
 *
 * @class TUIRoomEngine
 */
declare class TUIRoomEngine {
    static className: string;
    private static isReady;
    private roomEngineWASM;
    private trtcCloud;
    private deviceManager;
    private deviceManagerWASM;
    private conferenceListManager;
    private conferenceInvitationManager;
    private liveListManager;
    private liveLayoutManager;
    private static userId;
    private static sdkAppId;
    private static Module;
    private static shareInstance;
    private logger;
    private roomId;
    private localVideoQuality;
    private localAudioQuality;
    static setModule(Module: any): void;
    static once(event: string, func: (...args: any[]) => void): void;
    static getInstance(): TUIRoomEngine;
    constructor(options?: {
        isSharedInstance?: boolean;
    });
    /**
     * @private
     * 调用 TUIRoomEngineWASM 的静态方法
     */
    private static JSCallNativeFunctionPromise;
    /**
     * @private
     * 调用 TUIRoomEngineWASM 的异步方法
     * @param funcName
     * @param args
     */
    private JSCallNativeFunctionPromise;
    private JSCallNativeRequestFunctionPromise;
    /**
     * 登录 TUIRoomEngine
     *
     * @param {object} options
     * @param {number} options.sdkAppId sdkAppId <br>
     * 在 [实时音视频控制台](https://console.cloud.tencent.com/trtc) 单击 **应用管理** > **创建应用** 创建新应用之后，即可在 **应用信息** 中获取 sdkAppId 信息。
     * @param {string} options.userId 用户ID <br>
     * 建议限制长度为32字节，只允许包含大小写英文字母(a-zA-Z)、数字(0-9)及下划线和连词符。
     * @param {string} options.userSig userSig 签名 <br>
     * 计算 userSig 的方式请参考 [UserSig 相关](https://cloud.tencent.com/document/product/647/17275)。
     * @returns {Promise<void>}
     *
     * @example
     * // 登录 TUIRoomEngine
     * await TUIRoomEngine.login({
     *  sdkAppId: 0,   // 填写您申请的 sdkAppId
     *  userId: '',    // 填写您业务对应的 userId
     *  userSig: '',   // 填写服务器或本地计算的 userSig
     * })
     */
    static login(options: {
        sdkAppId: number;
        userId: string;
        userSig: string;
        tim?: ChatSDK;
    }): Promise<void>;
    /**
     * 设置当前用户基本信息（用户名、用户头像）
     *
     * @param {object} options
     * @param {string} options.userName 用户名，必填
     * @param {string} options.avatarUrl 用户头像，必填
     * @param {object=} options.customInfo 用户自定义资料, customInfo 字段自 v2.2.0 版本废弃
     * App 管理员可以通过 [即时通信 IM 控制台 > 用户自定义字段](https://console.cloud.tencent.com/im/user-data) 新增自定义资料字段
     * 用户自定义字段生效以后，用户可以调用 setSelfInfo 接口设置自定义资料
     * @returns {Promise<void>}
     *
     * @example
     * // 设置当前用户用户名及用户头像
     * await TUIRoomEngine.setSelfInfo({
     *  userName: '',     // 填写您的新用户名
     *  avatarUrl: '',    // 填写您的新头像地址
     * })
     *
     * // 设置当前用户用户名, 用户头像及用户自定义消息
     * await TUIRoomEngine.setSelfInfo({
     *  userName: '',     // 填写您的新用户名
     *  avatarUrl: '',    // 填写您的新头像地址
     *  customInfo: {     // 填写用户自定义消息
     *    Tag_Profile_Custom_Test: 'value1',
     *    Tag_Profile_Custom_profile: 'value2,
     *  },
     * })
     */
    static setSelfInfo(options: {
        userName: string;
        avatarUrl: string;
        customInfo?: Record<string, any>;
    }): Promise<void>;
    /** 获取当前用户信息接口
     * @returns {Promise<TUILoginUserInfo>} loginUserInfo
     * 该接口返回用户信息
     *
     * @example
     * await TUIRoomEngine.getSelfInfo();
     */
    static getSelfInfo(): Promise<TUILoginUserInfo>;
    /**
     * 登出 TUIRoomEngine, 登出 TUIRoomEngine 时将销毁所有 roomEngine 实例
     *
     * @example
     * await TUIRoomEngine.logout();
     */
    static logout(): Promise<void>;
    /**
     * 主持人创建房间，调用 createRoom 的用户为房间的所有者。创建房间时可设置房间 Id，房间名称，房间类型，发言模式以及房间是否允许加入用户开启音视频，发送消息等功能。
     *
     * @param {object} options
     * @param {string} options.roomId 房间 Id，必填, roomId 限制长度为64字节，且仅支持以下范围的字符集：<br>
     * - 大小写英文字母（a-zA-Z）
     * - 数字（0-9）
     * - 空格 ! # $ % & ( ) + - : ; < = . > ? @ [ ] ^ _ { } | ~ ,
     * @param {string=} [options.roomName=roomId] 房间名称，默认值为 roomId，传入的值不能为空字符串
     * @param {TUIRoomType=} [options.roomType=TUIRoomType.kConference] 房间类型, 默认值为 TUIRoomType.kConference <br>
     * 办公协同、医疗问诊、远程会议、教育场景，roomType 设置为 TUIRoomType.kConference
     * 电商直播、语聊房场景，roomType 设置为 TUIRoomType.kLive
     * @param {boolean=} [options.isSeatEnabled=false] 是否开启麦位控制，默认值为 false
     * @param {TUISeatMode=} [options.seatMode=TUISeatMode.kFreeToTake] 上麦模式(开启麦位控制后生效)，默认值为 TUISeatMode.kFreeToTake <br>
     * 自由上麦模式，台下观众可以自由上麦，无需申请，seatMode 设置为 TUISeatMode.kFreeToTake
     * 申请上麦模式，台下观众上麦需要房主或者管理员同意后才能上麦，seatMode 设置为 TUISeatMode.kApplyToTake
     * @param {boolean=} [options.isMicrophoneDisableForAllUser=false] 是否开启全员禁麦，默认不开启全员禁麦（创建房间可选参数）
     * @param {boolean=} [options.isScreenShareDisableForAllUser=false] 是否开启禁止屏幕分享，默认不开启禁止屏幕分享权限（该属性自 v2.2.0 版本 以后支持，创建房间可选参数）
     * @param {boolean=} [options.isCameraDisableForAllUser=false] 是否开启全员禁画，默认不开启全员禁画（创建房间可选参数）
     * @param {boolean=} [options.isMessageDisableForAllUser=false] 是否允许成员发送消息，默认不禁止（创建房间可选参数）
     * @param {number=} options.maxSeatCount 最大麦位数量 （创建房间可选参数）
     * @param {string=} [options.password=''] 房间密码，（该属性自 v2.5.0 版本支持） <br>
     * roomType 为 TUIRoomType.kConference (教育及会议场景) 时，maxSeatCount 值不做限制；
     * roomType 为 TUIRoomType.kLive (直播场景) 时，maxSeatCount 最大限制为 16；
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.createRoom({
     *  roomId: '12345',   // 填入您的房间 Id, 注意房间 Id 要求为字符串类型
     *  roomName: 'Test Room',     // 填入您的房间名称, 房间名称默认为 roomId，最长 30 字节
     *  roomType: TUIRoomType.kConference, // 设置房间类型为 TUIRoomType.kConference 类型
     *  isSeatEnabled: false, // 不开启麦位控制
     *  password: '1234', // 填入您的房间密码，不填入则不设置房间密码
     * });
     */
    createRoom(options: {
        roomId: string;
        roomName?: string;
        roomType?: TUIRoomType;
        isSeatEnabled?: boolean;
        seatMode?: TUISeatMode;
        isMicrophoneDisableForAllUser?: boolean;
        isScreenShareDisableForAllUser?: boolean;
        isCameraDisableForAllUser?: boolean;
        isMessageDisableForAllUser?: boolean;
        maxSeatCount?: number;
        password?: string;
    }): Promise<void>;
    /**
     * 进入房间接口
     * @param {object} options
     * @param {string} options.roomId 房间号，字符串类型
     * @param {TUIRoomType} options.roomType 房间类型, 默认值为 TUIRoomType.kConference (自 v2.3.0 支持)
     * @param {TUIEnterRoomOptions} options.options 进入房间的可选参数 (自 v2.5.0 支持)
     * @returns {Promise<TUIRoomInfo>} roomInfo
     * 该接口返回当前房间信息
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const roomDetailInfo = await roomEngine.enterRoom({
     *  roomId: '12345',
     *  roomType: TUIRoomType.kConference, // 设置房间类型为 TUIRoomType.kConference 类型
     *  options: {
     *    password: '1234',
     *  }
     * });
     */
    enterRoom(options: {
        roomId: string;
        roomType: TUIRoomType;
        options?: TUIEnterRoomOptions;
    }): Promise<TUIRoomInfo>;
    /**
     * 解散房间接口，解散房间必须由房间所有者发起，解散房间之后房间不可进入
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.destroyRoom();
     */
    destroyRoom(): Promise<void>;
    /**
     * 离开房间接口，用户在执行 enterRoom 之后可通过 exitRoom 离开房间
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.exitRoom();
     */
    exitRoom(): Promise<void>;
    /**
     * 获取房间信息
     * @param {object} options
     * @param {string} options.roomId 要获取信息的房间Id。
     * @param {TUIRoomType} options.roomType 要获取信息的房间类型。
     * @returns {Promise<TUIRoomInfo>} roomInfo
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const roomInfo = await roomEngine.fetchRoomInfo({
     *  roomId: '12345',
     *  roomType: TUIRoomType.kConference,
     * });
     */
    fetchRoomInfo(options?: {
        roomId: string;
        roomType: TUIRoomType;
    }): Promise<TUIRoomInfo>;
    /**
     * 更新房间的名字（仅群主或者管理员可以调用）
     * @param {object} options
     * @param {string} options.roomName 更新当前房间的名字
     * @returns {Promise<void>}
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.createRoom({ roomId: '12345' });
     * await roomEngine.updateRoomNameByAdmin({ roomName: '新的名字' });
     */
    updateRoomNameByAdmin(options: {
        roomName: string;
    }): Promise<void>;
    /**
     * 更新房间上麦模式（仅群主或者管理员可以调用）
     * 房间上麦模式更新后，roomEngine 会通过 TUIRoomEvents.onRoomSeatModeChanged 回调通知房间内用户
     * @since v2.0.0
     * @param {object} options
     * @param {TUISeatMode} options.seatMode 发言类型
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.updateRoomSeatModeByAdmin({
     *   seatMode: TUISeatMode.kApplyToTake,  // 更新为申请上麦模式
     * });
     */
    updateRoomSeatModeByAdmin(options: {
        seatMode: TUISeatMode;
    }): Promise<void>;
    /**
     * 更新房间密码（仅群主或者管理员可以调用）
     *
     * @since v2.5.0
     * @param {object} options
     * @param {string} options.password 房间密码,传入空字符串则代表关闭房间密码
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.updateRoomPasswordByAdmin({
     *   password: '1234',  // 更新密码为 1234
     * });
     */
    updateRoomPasswordByAdmin(options: {
        password: string;
    }): Promise<void>;
    /**
     * 获取当前房间用户列表，注意该接口一次拉取的用户列表量最大为 50 个
     *
     * @param {object=} options 获取用户列表的参数
     * @param {number=} options.nextSequence 偏移量，默认从 0 开始拉取用户<br/>
     * @return {Promise<object>} result
     * result.nextSequence 下一次拉取群组用户的偏移量，如果 nextSequence 为 0 则代表 userList 全部拉下来了
     * result.userInfoList 本次拉取的 userList
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const userList = [];
     * let result;
     * let nextSequence = 0;
     * do {
     *  result = await roomEngine.getUserList({ nextSequence });
     *  userList.push(...result.userInfoList);
     *  nextSequence = result.nextSequence;
     * } while (nextSequence !== 0)
     */
    getUserList(options?: {
        nextSequence?: number;
    }): Promise<Array<TUIUserInfo>>;
    /**
     * 获取用户的详细信息
     * @param {object} options 获取用户信息的参数
     * @param {string} options.userId 根据 userId 获取该用户的详细信息
     * @returns Promise<TUIUserInfo> userInfo
     * 该接口返回指定用户的用户信息
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const userInfo = await roomEngine.getUserInfo({
     *   userId: 'user_12345',
     * });
     */
    getUserInfo(options: {
        userId: string;
    }): Promise<any>;
    /**
     * 设置用户的自定义信息，该接口需要在进房后调用；
     * 主持人可以设置自己，管理员及普通用户的自定义信息；
     * 管理员可以设置自己及普通用户的自定义信息；
     * 普通用户仅可以设置自己的自定义信息；
     * @param {object} options 设置用户的自定义信息
     * @param {string} options.userId 用户 userId
     * @param {object} options.customInfo 用户自定义信息
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.setCustomInfoForUser({
     *   userId: 'user_12345',
     *   customInfo: {
     *     'key1': 'value1',
     *     'key2': 'value2',
     *   }
     * });
     */
    setCustomInfoForUser(options: {
        userId: string;
        customInfo: Record<string, string>;
    }): Promise<void>;
    /**
     * 设置本地视频流的渲染位置
     * @param {object} options 设置本地视频流的渲染位置的参数
     * @param {string | Array<string> | null} options.view 本地视频流的渲染位置，如果传入 null 则不预览摄像头画面，但不影响摄像头采集，会正常推流。
     * @returns {Promise<void>}
     * @desc 自 v1.6.1 版本起，setLocalVideoView 不再需要传入 streamType 参数
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     *
     * // 设置本地摄像头流的播放区域为 id 是 'preview-camera' 的 div 元素
     * roomEngine.setLocalVideoView({
     *  view: 'preview-camera',
     * });
     */
    setLocalVideoView(options: {
        view: string | Array<string> | null;
        streamType?: TUIVideoStreamType;
    }): void;
    /**
     * 打开本地摄像头，开始视频流采集
     * @param {object} options 设置本地流的参数
     * @returns {Promise<void>}
     * @example
     * const roomEngine = new TUIRoomEngine();
     *
     * // 桌面端打开摄像头
     * await roomEngine.openLocalCamera();
     *
     * // 移动端使用前置摄像头打开视频预览
     * await roomEngine.openLocalCamera({ isFrontCamera: true });
     * // 移动端使用后置摄像头打开视频预览
     * await roomEngine.openLocalCamera({ isFrontCamera: false });
     */
    openLocalCamera(options?: {
        isFrontCamera?: boolean;
    }): Promise<void>;
    /**
     * 关闭本地摄像头
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.closeLocalCamera();
     */
    closeLocalCamera(): Promise<void>;
    /**
     * 打开麦克风
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.openLocalMicrophone();
     */
    openLocalMicrophone(): Promise<void>;
    /**
     * 关闭本地麦克风, 停止采集音频流
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.closeLocalMicrophone();
     */
    closeLocalMicrophone(): Promise<void>;
    /**
     * 设置本地视频流的编码参数
     * @param {object} options
     * @param {TUIVideoQuality} options.quality
     *
     * - 360p TUIVideoQuality.kVideoQuality_360p <br/>
     * - 540p TUIVideoQuality.kVideoQuality_540p <br/>
     * - 720p TUIVideoQuality.kVideoQuality_720p <br/>
     * - 1080p TUIVideoQuality.kVideoQuality_1080p <br/>
     *
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.updateVideoQuality({
     *  quality: TUIVideoQuality.kVideoQuality_360p,
     * });
     */
    updateVideoQuality(options: {
        quality: TUIVideoQuality;
    }): Promise<void>;
    /**
     * 设置本地视频流的分辨率模式
     * @param {object} options
     * @param {TUIVideoStreamType} options.streamType
     * @param {TUIResolutionMode} options.resolutionMode
     *
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.setVideoResolutionMode({
     *  type: TUIVideoStreamType.kCameraStream,
     *  resolutionMode: TUIResolutionMode.kResolutionMode_Landscape,
     * });
     */
    setVideoResolutionMode(options: {
        streamType: TUIVideoStreamType;
        resolutionMode: TUIResolutionMode;
    }): Promise<void>;
    /**
     * 设置本地视频流的详细编码参数
     * @param {object} options
     * @param {TUIVideoStreamType} options.streamType
     * @param {TUIVideoEncoderParams} options.encoderParams
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.updateVideoQualityEx({
     *  streamType: TUIVideoStreamType.kCameraStream,
     *  encoderParams: {
     *   videoResolution: TUIVideoQuality.kVideoQuality_720p,
     *   fps: 15,
     *   bitrate: 2000,
     *   resMode: TUIResolutionMode.kResolutionMode_Landscape,
     *  }
     * });
     */
    updateVideoQualityEx(options: {
        streamType: TUIVideoStreamType;
        encoderParams: TUIVideoEncoderParams;
    }): Promise<void>;
    /**
     * 设置本地音频的参数<br/>
     * @param {object} options 设置本地音频的参数
     * @param {TUIAudioQuality} options.quality
     *
     * - TUIAudioQuality.kAudioProfileSpeech：语言模式；采样率：16k<br/>
     * - TUIAudioQuality.kAudioProfileDefault：标准模式（或者默认模式）；采样率：48k<br/>
     * - TUIAudioQuality.kAudioProfileMusic：音乐模式；采样率：48k
     *
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.updateAudioQuality({
     *  quality: TUIAudioQuality.kAudioProfileSpeech,
     * });
     */
    updateAudioQuality(options: {
        quality: TUIAudioQuality;
    }): Promise<void>;
    /**
     * 开始向远端推本地视频流
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.startPushLocalVideo();
     */
    startPushLocalVideo(): Promise<void>;
    /**
     * 停止向远端推本地视频流
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.startPushLocalVideo();
     */
    stopPushLocalVideo(): Promise<void>;
    /**
     * 开始向远端推本地音频流
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.muteLocalAudio();
     * @since 1.5.1
     */
    muteLocalAudio(): Promise<void>;
    /**
     * 停止向远端推本地音频流
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.unmuteLocalAudio();
     * @since 1.5.1
     */
    unmuteLocalAudio(): Promise<void>;
    /**
     * 设置远端流渲染的区域
     *
     * @param {object} options 设设置远端流渲染区域的参数
     * @param {string} options.userId 用户 Id
     * @param {TUIVideoStreamType} options.streamType 用户流类型
     * @param {string | Array<string>} options.view 播放远端用户流的 div 元素的 id
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     *
     * // 设置远端用户视频流在 id 为 'remote_preview_camera' 的区域播放
     * roomEngine.setRemoteVideoView()({
     *  userId: 'user_1234',
     *  streamType: TUIVideoStreamType.kCameraStream,
     *  view: 'remote_preview_camera',
     * });
     *
     * // 设置远端用户屏幕分享流在 id 为 'remote_preview_screen' 的区域播放
     * roomEngine.setRemoteVideoView()({
     *  userId: 'user_1234',
     *  streamType: TUIVideoStreamType.kScreenStream,
     *  view: 'remote_preview_screen',
     * });
     */
    setRemoteVideoView(options: {
        userId: string;
        streamType: TUIVideoStreamType;
        view: string | Array<string>;
    }): Promise<void>;
    /**
     * 开始播放远端用户视频流
     *
     * @param {object} options 开始播放远端用户视频流的参数
     * @param {string} options.userId 用户 Id
     * @param {TUIVideoStreamType} options.streamType 用户流类型
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.startPlayRemoteVideo({
     *  userId: 'user_1234',
     *  streamType: TUIVideoStreamType.kCameraStream,
     * });
     */
    startPlayRemoteVideo(options: {
        userId: string;
        streamType: TUIVideoStreamType;
    }): Promise<void>;
    /**
     * 停止播放远端用户视频流
     *
     * @param {object} options 停止播放远端用户视频流的参数
     * @param {string} options.userId 用户 Id
     * @param {TUIVideoStreamType} options.streamType 用户流类型<br/>
     *
     * - TUIVideoStreamType.kCameraStream 视频流<br/>
     * - TUIVideoStreamType.kScreenStream 屏幕分享流<br/>
     * - TUIVideoStreamType.kCameraStreamLow 低清视频流
     *
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.stopPlayRemoteVideo({
     *  userId: 'user_1234',
     *  streamType: TUIVideoStreamType.kCameraStream,
     * });
     */
    stopPlayRemoteVideo(options: {
        userId: string;
        streamType: TUIVideoStreamType;
    }): Promise<void>;
    /**
     * 停止远端用户的音频流
     * @param {object} options 停止远端用户音频流的参数
     * @param {string} options.userId 停止远端用户的userId
     * @param {boolean} options.isMute 是否停止远端用户的音频
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.muteRemoteAudioStream({
     *  userId: 'user_1234',
     *  isMute: true,
     * });
     */
    muteRemoteAudioStream(options: {
        userId: string;
        isMute: boolean;
    }): Promise<void>;
    /**
     * 请求远端用户打开媒体设备
     * @param {object} options 请求远端用户打开摄像头的参数
     * @param {string} options.userId 用户 Id
     * @param {TUIMediaDevice} options.device 请求的设备
     * @param {number} options.timeout 超时时间。若 timeout 设置为 0 ，则无超时时间
     * @param {Function} 请求回调，用来通知发起方请求被接受/拒绝/取消/超时/错误的回调
     * @return {Promise<TUIRequest>} <br/>
     * 该接口返回 request 结构体，当 request.requestId 不为 '' 时，用户可调用 cancelRequest 接口取消请求。
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const request = roomEngine.openRemoteDeviceByAdmin({
     *   userId: 'user_1234',
     *   device: TUIMediaDevice.kMicrophone  //请求的设备为麦克风
     *   timeout: 0,
     *   requestCallback: ({ requestCallbackType, requestId, userId, code, message }) => {
     *    switch (requestCallbackType) {
     *      case TUIRequestCallbackType.kRequestAccepted:
     *        // 请求被接受
     *        break;
     *      case TUIRequestCallbackType.kRequestRejected:
     *        // 请求被拒绝
     *        break;
     *      case TUIRequestCallbackType.kRequestCancelled:
     *        // 请求已取消
     *        break;
     *      case TUIRequestCallbackType.kRequestTimeout:
     *        // 请求超时
     *        break;
     *      case TUIRequestCallbackType.kRequestError:
     *        // 请求错误
     *        break;
     *      default:
     *        break;
     *    }
     *  },
     * });
     */
    openRemoteDeviceByAdmin(options: {
        userId: string;
        device: TUIMediaDevice;
        timeout: number;
        requestCallback?: (callbackInfo: TUIRequestCallback) => void;
    }): Promise<TUIRequest>;
    /**
     * 参会者向主持人申请打开设备
     *
     * @param {object} options 请求远端用户打开摄像头的参数
     * @param {TUIMediaDevice} options.device 请求的设备
     * @param {number} options.timeout 超时时间。若 timeout 设置为 0 ，则无超时时间
     * @param {Function} 请求回调，用来通知发起方请求被接受/拒绝/取消/超时/错误的回调
     * @return {Promise<TUIRequest>} <br/>
     * 该接口返回 request 结构体，当 request.requestId 不为 '' 时，用户可调用 cancelRequest 接口取消请求。
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const request = roomEngine.applyToAdminToOpenLocalDevice({
     *   device: TUIMediaDevice.kMicrophone, //请求打开麦克风
     *   timeout: 0,
     *   requestCallback: ({ requestCallbackType, requestId, userId, code, message }) => {
     *    switch (requestCallbackType) {
     *      case TUIRequestCallbackType.kRequestAccepted:
     *        // 请求被接受
     *        break;
     *      case TUIRequestCallbackType.kRequestRejected:
     *        // 请求被拒绝
     *        break;
     *      case TUIRequestCallbackType.kRequestCancelled:
     *        // 请求已取消
     *        break;
     *      case TUIRequestCallbackType.kRequestTimeout:
     *        // 请求超时
     *        break;
     *      case TUIRequestCallbackType.kRequestError:
     *        // 请求错误
     *        break;
     *      default:
     *        break;
     *    }
     *  },
     * });
     */
    applyToAdminToOpenLocalDevice(options: {
        device: TUIMediaDevice;
        timeout: number;
        requestCallback?: (callbackInfo: TUIRequestCallback) => void;
    }): Promise<TUIRequest>;
    /**
     * 关闭远端用户媒体设备
     *
     * @param {object} options 关闭远端用户摄像头的参数
     * @param {string} options.userId 用户 Id
     * @param {TUIMediaDevice} options.device 用户 Id
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.closeRemoteDeviceByAdmin({
     *   userId: 'user_1234',
     *   device: TUIMediaDevice.kMicrophone, //关闭掉麦克风
     * });
     */
    closeRemoteDeviceByAdmin(options: {
        userId: string;
        device: TUIMediaDevice;
    }): Promise<void>;
    /**
     * 取消已经发出的请求
     * @param {object} options 取消已经发出请求的参数
     * @param {string} options.requestId 请求 Id
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.cancelRequest({
     *  requestId: '',    // 请使用实际 requestId
     * });
     */
    cancelRequest(options: {
        requestId: string;
    }): Promise<void>;
    /**
     * 回复远端用户的请求
     * @param {object} options 回复远端用户的请求的参数
     * @param {string} options.requestId 请求 Id
     * @param {boolean} options.agree 是否同意
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     *
     * // 同意远端的请求
     * await roomEngine.responseRemoteRequest({
     *  requestId: '',    // 请使用实际 requestId
     *  agree: true,
     * });
     *
     * // 拒绝远端的请求
     * await roomEngine.responseRemoteRequest({
     *  requestId: '',    // 请使用实际 requestId
     *  agree: false,
     * });
     */
    responseRemoteRequest(options: {
        requestId: string;
        agree: boolean;
    }): Promise<any>;
    /**
     * 禁止/允许所有用户打开媒体设备（此接口对于房主和管理员无效）
     * @param {object} options
     * @param {TUIMediaDevice} options.device 操作的媒体设备
     * @param {boolean} options.isDisable 是否被禁止
     * @returns {Promise<void>}
     * @example
     * // Example 1: 禁止所有用户打开麦克风
     * await roomEngine.disableDeviceForAllUserByAdmin({
     *  device: TUIMediaDevice.kMicrophone,
     *  isDisable: true,
     * })
     * // Example 2: 允许所有用户打开麦克风
     * await roomEngine.disableDeviceForAllUserByAdmin({
     *  device: TUIMediaDevice.kMicrophone,
     *  isDisable: false,
     * })
     */
    disableDeviceForAllUserByAdmin(options: {
        device: TUIMediaDevice;
        isDisable: boolean;
    }): Promise<void>;
    /**
     * 禁止/允许所有用户发送消息
     * @param {object} options
     * @param {boolean} options.isDisable 是否被禁止
     * @returns {Promise<void>}
     * @example
     * await roomEngine.disableSendingMessageForAllUser({
     *  isDisable: true,
     * })
  
     */
    disableSendingMessageForAllUser(options: {
        isDisable: boolean;
    }): Promise<void>;
    /**
     * 禁止/允许某个用户发送消息
     * @param {object} options
     * @param {string} options.userId 用户的 Id
     * @param {boolean} options.isDisable 是否被禁止
     * @returns {Promise<void>}
     * @example
     * await roomEngine.disableSendingMessageByAdmin({
     *  userId: 'user_1234',
     *  isDisable: true,
     * })
     */
    disableSendingMessageByAdmin(options: {
        userId: string;
        isDisable: boolean;
    }): Promise<void>;
    /**
     * 改变用户的角色，仅主持人可调用该接口
     * @param {object} options 改变用户的角色，仅主持人可调用该接口的参数
     * @param {string} options.userId 用户 Id
     * @param {TUIRole} options.userRole 用户角色
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * // 将房间移交给用户 user_1234
     * await roomEngine.changeUserRole({
     *  userId: 'user_1234',
     *  userRole: TUIRole.kRoomOwner,
     * });
     *
     * // 将用户 user_1234 设置为房间管理员
     * await roomEngine.changeUserRole({
     *  userId: 'user_1234',
     *  userRole: TUIRole.kAdministrator,
     * });
     */
    changeUserRole(options: {
        userId: string;
        userRole: TUIRole;
    }): Promise<void>;
    /**
     * 修改房间内用户名称
     * @since v2.5.0
     * @param {object} options 修改房间内用户名称，普通成员可修改自己的，管理员可修改自己和普通成员的。
     * @param {string} options.userId 用户 Id
     * @param {string} options.nameCard 房间内用户名称
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * // 修改房间内用户名称
     * await roomEngine.changeUserNameCard({
     *  userId: 'user_1234',
     *  nameCard: 'jack',
     * });
     *
     */
    changeUserNameCard(options: {
        userId: string;
        nameCard: string;
    }): Promise<void>;
    /**
     * 将用户踢出房间，仅主持人和管理员可调用该接口
     * @param {object} options
     * @param {string} options.userId 用户 Id
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.kickRemoteUserOutOfRoom({
     *  userId: 'user_1234',
     * });
     */
    kickRemoteUserOutOfRoom(options: {
        userId: string;
    }): Promise<void>;
    /**
     * 获取麦位列表
     * @returns {Promise<TUISeatInfo[]>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const seatList = await roomEngine.getSeatList();
     * ;
     */
    getSeatList(): Promise<TUISeatInfo[]>;
    /**
     * 麦下用户可调用 takeSeat 成为麦上用户，仅麦上用户可发布本地音视频流。<br/>
     * 主持人&管理员调用 takeSeat 成功后即为麦上用户。<br/>
     * roomInfo.seatMode 为 TUISeatMode.kFreeToTake 模式时，普通用户调用 takeSeat 方法成功后即为麦上用户。<br/>
     * roomInfo.seatMode 为 TUISeatMode.kApplyToTake 模式时，普通用户调用 takeSeat 方法需要等待主持人/管理员的同意后成为麦上用户。<br/>
     * 麦上用户的变更通过 TUIRoomEvents.onSeatListChanged 通知所有用户。<br/>
     * @param {object} options 获取麦位的参数
     * @param {number} options.seatIndex 麦位 index, 无麦位序号时设置为 -1
     * @param {number} options.timeout 超时时间。若 timeout 设置为 0，则无超时时间
     * @param {Function} options.requestCallback 请求回调，用来通知发起方请求被接受/拒绝/取消/超时/错误的回调
     * @returns {Promise<TUIRequest>} <br/>
     * 该接口返回 request 结构体，当 request.requestId 不为 '' 时，用户可调用 cancelRequest 接口取消上麦请求。
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     *
     * // 情景一：主持人/管理员上麦
     * // 情景二：roomInfo.seatMode 为 TUISeatMode.kFreeToTake 模式时，普通用户上麦
     * await roomEngine.takeSeat({
     *  seatIndex: -1,
     *  timeout: 0,
     * });
     *
     * // 情景三：roomInfo.seatMode 为 TUISeatMode.kApplyToTake 模式时，普通用户上麦
     * const request = await roomEngine.instance?.takeSeat({
     *  seatIndex: -1,
     *  timeout: 0,
     *  requestCallback: ({ requestCallbackType, requestId, userId, code, message }) => {
     *    switch (requestCallbackType) {
     *      case TUIRequestCallbackType.kRequestAccepted:
     *        // 请求被接受
     *        break;
     *      case TUIRequestCallbackType.kRequestRejected:
     *        // 请求被拒绝
     *        break;
     *      case TUIRequestCallbackType.kRequestCancelled:
     *        // 请求已取消
     *        break;
     *      case TUIRequestCallbackType.kRequestTimeout:
     *        // 请求超时
     *        break;
     *      case TUIRequestCallbackType.kRequestError:
     *        // 请求错误
     *        break;
     *      default:
     *        break;
     *    }
     *  },
     * });
     */
    takeSeat(options: {
        seatIndex: number;
        timeout: number;
        requestCallback?: (callbackInfo: TUIRequestCallback) => void;
    }): Promise<TUIRequest>;
    /**
     * 离开麦位
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.leaveSeat();
     */
    leaveSeat(): Promise<void>;
    /**
     * 移麦
     *
     * 移麦成功后,SDK会通过 onSeatListChanged 回调通知房间内用户。
     *
     * @param {number} options.targetSeatIndex 移麦目标麦位 index, 移麦成功后您将会在此麦位上。
     * @returns {Promise<void>}
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.moveToSeat({ targetSeatIndex: 1 });
     */
    moveToSeat(options: {
        targetSeatIndex: number;
    }): Promise<void>;
    /**
     * 邀请其他人上麦（仅房间主持人和管理员可调用此方法）
     * @param {object} options 邀请其他人上麦的参数
     * @param {number} options.seatIndex  麦位 index, roomType 为 TUIRoomType.kConference 时无需关心，填 -1 即可
     * @param {string} options.userId  用户 Id
     * @param {number} options.timeout  超时时间，设置为 0 时，无超时时间
     * @param {Function} options.requestCallback 请求回调，用来通知发起方请求被接受/拒绝/取消/超时/错误的回调
     * @returns {Promise<TUIRequest>} <br/>
     * 该接口返回 request 结构体，当 request.requestId 不为 '' 时，用户可调用 cancelRequest 接口取消请求。
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const request = await roomEngine.takeUserOnSeatByAdmin({
     *   seatIndex: 0,
     *   userId: 'user_1234',
     *   timeout: 0,
     *   requestCallback: ({ requestCallbackType, requestId, userId, code, message }) => {
     *    switch (requestCallbackType) {
     *      case TUIRequestCallbackType.kRequestAccepted:
     *        // 请求被接受
     *        break;
     *      case TUIRequestCallbackType.kRequestRejected:
     *        // 请求被拒绝
     *        break;
     *      case TUIRequestCallbackType.kRequestCancelled:
     *        // 请求已取消
     *        break;
     *      case TUIRequestCallbackType.kRequestTimeout:
     *        // 请求超时
     *        break;
     *      case TUIRequestCallbackType.kRequestError:
     *        // 请求错误
     *        break;
     *      default:
     *        break;
     *    }
     *  },
     * });
     */
    takeUserOnSeatByAdmin(options: {
        seatIndex: number;
        userId: string;
        timeout: number;
        requestCallback?: (callbackInfo: TUIRequestCallback) => void;
    }): Promise<TUIRequest>;
    /**
     * 将其他人踢下麦（仅房间主持人和管理员可调用此方法）
     * @param {object} options 要求其他人下麦的参数
     * @param {number} options.seatIndex 麦位 index
     * @param {string} options.userId 用户 Id
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.kickUserOffSeatByAdmin({
     *   seatIndex: 0,
     *   userId: 'user_1234',
     * });
     */
    kickUserOffSeatByAdmin(options: {
        seatIndex: number;
        userId: string;
    }): Promise<void>;
    /**
     * 锁定某个麦位状态（仅房间主持人和管理员可调用此方法）
     *
     * @param {object} options 锁定某个麦位需要的参数
     * @param {number} options.seatIndex 麦位索引
     * @param {TUISeatLockParams} options.lockParams 锁麦参数
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.lockSeatByAdmin({
     *  seatIndex: -1,
     *  lockParams: {
     *    lockSeat: true,
     *    lockVideo: true,
     *    lockAudio: true,
     *  }
     * });
     */
    lockSeatByAdmin(options: {
        seatIndex: number;
        lockParams: TUISeatLockParams;
    }): Promise<any>;
    /**
     * 主持人/管理员 获取房间内申请上麦用户的请求列表
     * @returns {Promise<TUIRequest[]>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const seatList = await roomEngine.getSeatApplicationList();
     * ;
     */
    getSeatApplicationList(): Promise<TUIRequest[]>;
    /**
     * 发送文本消息
     * @deprecated 该接口自 v2.0.0 版本废弃，请使用 {@link getTIM} 方法获取 tim 实例发送消息
     * @param {object} options
     * @param {string} options.messageText 文本消息内容
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.sendTextMessage({
     *  messageText: 'hello, everyone',
     * });
     */
    sendTextMessage(options: {
        messageText: string;
    }): Promise<void>;
    /**
     * 发送自定义消息
     * @deprecated 该接口自 v2.0.0 版本废弃，请使用 {@link getTIM} 方法获取 tim 实例发送消息
     * @param {object} options
     * @param {string} options.messageText 自定义消息内容
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.sendCustomMessage({
     *  messageText: '{ data:'', description: ''}',
     * });
     */
    sendCustomMessage(options: {
        messageText: string;
    }): Promise<void>;
    /**
     * 开始屏幕共享
     * @param {object=} options
     * @param {boolean=} [options.screenAudio=false] web 端屏幕共享是否可选共享系统声音, screenAudio 默认值为 false
     * @param {string=} options.view 非必填，本地预览屏幕分享的 dom 元素的 id
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * // example 1: 开始屏幕分享
     * await roomEngine.startScreenSharing();
     * // example 2: 开始屏幕分享(可采集系统音频)
     * await roomEngine.startScreenSharing({ screenAudio: true });
     * // example 3: 开始屏幕分享并在本地预览
     * await roomEngine.startScreenSharing({ view: 'screen-preview' });
     */
    startScreenSharing(options?: {
        screenAudio?: boolean;
        view?: string;
    }): Promise<void>;
    /**
     * 停止屏幕共享
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.stopScreenSharing();
     */
    stopScreenSharing(): Promise<void>;
    /**
     * 开始屏幕共享 Electron
     * @param {object} options Electron 开始屏幕共享参数
     * @param {string} options.targetId 分享窗口 id, 可从 getScreenSharingTarget 获取
     * @param {string=} options.view 非必填，本地预览屏幕分享的 dom 元素的 id
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * // example 1: 开始屏幕共享
     * await roomEngine.startScreenSharingElectron({ targetId: 'xxx' });
     * // example 2: 开始屏幕共享并在本地预览
     * await roomEngine.startScreenSharingElectron({ targetId: 'xxx', view: 'screen-preview' });
     *
     */
    startScreenSharingElectron(options: {
        targetId: string;
        view?: string;
    } | string): Promise<void>;
    /**
     * 停止屏幕共享 Electron
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.stopScreenSharingElectron();
     */
    stopScreenSharingElectron(): Promise<void>;
    /**
     * 获取屏幕分享列表 Electron
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const screenList = await roomEngine.getScreenSharingTarget();
     */
    getScreenSharingTarget(): Promise<Array<TRTCScreenCaptureSourceInfo>>;
    /**
     * 切换屏幕分享窗口 Electron
     * @param {object} options Electron 切换屏幕分享窗口参数
     * @param {string} options.targetId 分享窗口 id, 可从 getScreenSharingTarget 获取
     *
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.selectScreenSharingTarget({ targetId: 'xxx' });
     */
    selectScreenSharingTarget(options: {
        targetId: string;
    } | string): Promise<void>;
    /**
     * 监听 roomEngine 的事件
     * @param event TUIRoomEvents
     * @param func function
     * @returns {void}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.on(event, func);
     */
    on(event: TUIRoomEvents, func: (...args: any[]) => void): void;
    private observerFunction;
    private supportForDeprecatedEvents;
    /**
     * 取消监听 roomEngine 的事件
     * @param event TUIRoomEvents
     * @param func function
     * @returns {void}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * roomEngine.off(event, func);
     */
    off(event: string, func: (...args: any[]) => void): void;
    private handleTrtcCloudBindEvent;
    private handleTrtcAutoPlayFailedEvent;
    /**
     * 获取摄像头设备列表<br>
     * @returns {Promise<TRTCDeviceInfo[]>} 摄像头列表
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const cameralist = await roomEngine.getCameraDevicesList();
     * for (i = 0; i < cameralist.length; i++) {
     *    var camera = cameralist[i];
     *    console.info("camera deviceName: " + camera.deviceName + " deviceId:" + camera.deviceId);
     * }
     */
    getCameraDevicesList(): Promise<any>;
    /**
     * 获取麦克风设备列表<br>
     * @returns {Promise<TRTCDeviceInfo[]>} 麦克风列表
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const micList = await roomEngine.getMicDevicesList();
     * for (i = 0; i < micList.length; i++) {
     *    var mic = micList[i];
     *    console.info("mic deviceName: " + mic.deviceName + " deviceId:" + mic.deviceId);
     * }
     */
    getMicDevicesList(): Promise<any>;
    /**
     * 获取扬声器设备列表<br>
     * @returns {Promise<TRTCDeviceInfo[]>} 扬声器列表
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const speakerList = await roomEngine.getSpeakerDevicesList();
     * for (i = 0; i < speakerList.length; i++) {
     *    var speaker = speakerList[i];
     *    console.info("speaker deviceName: " + speaker.deviceName + " deviceId:" + speaker.deviceId);
     * }
     */
    getSpeakerDevicesList(): Promise<any>;
    /**
     * 设置要使用的摄像头设备<br>
     * @param {Object} options
     * @param {String} options.deviceId - 从 getCameraDevicesList 中得到的设备 ID
     * @returns {Promise<void>}
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.setCurrentCameraDevice({ deviceId: '' });
     */
    setCurrentCameraDevice(options: {
        deviceId: string;
    }): Promise<void>;
    /**
     * 切换前后置摄像头，该接口只适用于移动端浏览器
     * @param {Object} options
     * @param {boolean} options.isFrontCamera 是否切换为前置摄像头
     *
     * // 移动端切换为前置摄像头
     * await roomEngine.switchCamera({ isFrontCamera: true });
     * // 移动端切换为后置摄像头
     * await roomEngine.switchCamera({ isFrontCamera: false });
     */
    switchCamera(options: {
        isFrontCamera: boolean;
    }): Promise<void>;
    /**
     * 设置要使用的麦克风设备<br>
     * @param {Object} options
     * @param {String} options.deviceId - 从 getMicDevicesList 中得到的设备 ID
     * @returns {Promise<void>}
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.setCurrentMicDevice({ deviceId: '' });
     */
    setCurrentMicDevice(options: {
        deviceId: string;
    }): Promise<void>;
    /**
     * 设置要使用的扬声器设备<br>
     * @param {Object} options
     * @param {String} options.deviceId - 从 getSpeakerDevicesList 中得到的设备 ID
     * @returns {Promise<void>}
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.setCurrentSpeakerDevice({ deviceId: '' });
     */
    setCurrentSpeakerDevice(options: {
        deviceId: string;
    }): Promise<void>;
    /**
     * 获取当前正在使用的摄像头设备
     * @returns {TRTCDeviceInfo} 设备信息，能获取设备 ID 和设备名称
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const currentCameraDevice = roomEngine.getCurrentCameraDevice();
     */
    getCurrentCameraDevice(): TRTCDeviceInfo;
    /**
     * 获取当前正在使用的麦克风设备
     * @returns {TRTCDeviceInfo} 设备信息，能获取设备 ID 和设备名称
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const currentMicDevice = roomEngine.getCurrentMicDevice();
     */
    getCurrentMicDevice(): TRTCDeviceInfo;
    /**
     * 获取当前正在使用的扬声器设备
     * @returns {TRTCDeviceInfo} 设备信息，能获取设备 ID 和设备名称
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const currentSpeakerDevice = roomEngine.getCurrentSpeakerDevice();
     */
    getCurrentSpeakerDevice(): TRTCDeviceInfo;
    /**
     * 开始进行摄像头测试
     * @param {string} view 显示摄像头测试的视频区域, 传入的 view 为承载预览画面 div 元素的 id
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.startCameraDeviceTest({ view: 'test-preview' });
     */
    startCameraDeviceTest(options: {
        view: string;
    }): Promise<void>;
    /**
     * 停止摄像头测试
     * @returns {void}
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.stopCameraDeviceTest();
     */
    stopCameraDeviceTest(): Promise<void>;
    /**
     * 开始进行麦克风测试
     * @param options
     * @param {number} options.interval 麦克风音量的回调时间
     */
    startMicDeviceTest(options: {
        interval: number;
    }): Promise<void>;
    /**
     * 停止进行麦克风测试
     */
    stopMicDeviceTest(): Promise<void>;
    /**
     * v2.1.0 版本起支持使用 getMediaDeviceManager 获取 deviceManager 模块
     * @since v2.1.0
     * @example
     * // 获取设备管理模块
     * const deviceManager = roomEngine.getMediaDeviceManager();
     *
     * @returns {TUIRoomDeviceManager} deviceManager
     */
    getMediaDeviceManager(): TUIRoomDeviceManager;
    private handleDeviceManagerWASM;
    /**
     * v2.5.0 版本起支持使用 getConferenceListManager 获取 conferenceListManager 模块
     * @since v2.5.0
     *
     * @example
     * // 获取会议列表
     * const conferenceListManager = roomEngine.getConferenceListManager();
     *
     * @returns {TUIConferenceListManager} conferenceListManager
     */
    getConferenceListManager(): TUIConferenceListManager;
    /**
     * v3.0.0 版本起支持 getLiveListManager 获取 TUILiveListManager 模块
     *
     * @since v3.0.0
     * @returns {TUILiveListManager}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const liveListManager = roomEngine.getLiveListManager();
     */
    getLiveListManager(): TUILiveListManager;
    /**
     * v3.0.0 版本起支持 getLiveLayoutManager 获取 TUILiveLayoutManager 模块
     *
     * @since v3.0.0
     * @returns {TUILiveLayoutManager}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const liveLayoutManager = roomEngine.getLiveLayoutManager();
     */
    getLiveLayoutManager(): TUILiveLayoutManager;
    /**
     * v2.6.0 版本起支持使用 getConferenceInvitationManager 获取 conferenceInvitation 模块
     * @since v2.6.0
     *
     * @example
     * //获取会中邀请
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     *
     * @returns {TUIConferenceInvitationManager} conferenceInvitationManager
     */
    getConferenceInvitationManager(): TUIConferenceInvitationManager;
    /**
     * 获取 trtcCloud 实例
     * @returns {TRTCCloud} trtcCloud
     * web 端 trtcCloud 能力请查看：https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCloud.html
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const trtcCloud = roomEngine.getTRTCCloud();
     */
    getTRTCCloud(): TRTCCloud;
    /**
     * 获取 tim 实例
     * @returns {TIM} tim
     * web 端 tim 能力请查看：https://web.sdk.qcloud.com/im/doc/zh-cn/SDK.html
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const tim = roomEngine.getTIM();
     */
    getTIM(): ChatSDK;
    destroy(): void;
    /**
     * 实验性接口
     * @private
     * @param jsonStr jason 字符串
     * @returns
     */
    static callExperimentalAPI(jsonStr: string): Promise<void>;
    private static handleSetFramework;
}

export { TRTCRole, TUIAudioQuality, TUIAudioRoute, TUICaptureSourceType, TUIChangeReason, TUIConferenceCancelReason, TUIConferenceInvitationManager, TUIConferenceInvitationManagerEvents, TUIConferenceListManager, TUIConferenceListManagerEvents, TUIConferenceStatus, TUIErrorCode, TUIInvitationCode, TUIInvitationRejectedReason, TUIInvitationStatus, TUIKickedOutOfRoomReason, TUILiveLayoutManager, TUILiveLayoutManagerEvents, TUILiveListManager, TUILiveListManagerEvents, TUILiveModifyFlag, TUIMediaDevice, TUIMediaDeviceState, TUIMediaDeviceType, TUINetworkQuality, TUIRequestAction, TUIRequestCallbackType, TUIResolutionMode, TUIRole, TUIRoomDeviceManager, TUIRoomDeviceMangerEvents, TUIRoomDismissedReason, TUIRoomEvents, TUIRoomType, TUISeatMode, TUIVideoQuality, TUIVideoStreamType, TUIRoomEngine as default };
export type { TUIAutoPlayCallbackInfo, TUIConferenceInfo, TUIConferenceModifyInfo, TUIDeviceInfo, TUIEnterRoomOptions, TUIInvitation, TUILiveInfo, TUILiveListResult, TUILiveModifyInfo, TUILoginUserInfo, TUIMessage, TUINetwork, TUIRequest, TUIRequestCallback, TUIRoomInfo, TUISeatInfo, TUISeatLockParams, TUIUserInfo, TUIVideoEncoderParams };