import { ChatSDK } from '@tencentcloud/chat';
export { default as TIM, default as TencentCloudChat } from '@tencentcloud/chat';
import TRTCCloud from '@tencentcloud/trtc-component-wx';
export { default as TRTCCloud } from '@tencentcloud/trtc-component-wx';

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,
    kNetworkDisconnected = 3,
    kJoinRoomStatusInvalidDuringOffline = 4,
    kCountOfJoinedRoomsExceedLimit = 5
}
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;
    isLocked: 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;
    };
};
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-wx';
 * 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 {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",
    /**
     * @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",
    /**
     * @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 '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"
}
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 邀请信息。
     *
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const conferenceInvitationManager = roomEngine.getConferenceInvitationManager();
     * conferenceInvitationManager.on(TUIConferenceInvitationManagerEvents.onInvitationRejected, ({ roomInfo, invitation }) => {
     *  console.log('conferenceInvitationManager.onInvitationRejected', roomInfo, invitation);
     * })
     */
    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"
}

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 设备类型
     * @returns {Promise} Array<TUIDeviceInfo>
     */
    getDevicesList(options: {
        type: TUIMediaDeviceType;
    }): Promise<TUIDeviceInfo[]>;
    /**
     * 设置当前使用设备
     * @param {TRTCDeviceType} type 设备类型
     * @param {string} deviceId 设备 Id
     * @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;
    }): void;
    /**
     * 开始进行摄像头测试
     * @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;
}

declare enum TRTCVideoResolution {
    TRTCVideoResolution_120_120 = 1,
    TRTCVideoResolution_160_160 = 3,
    TRTCVideoResolution_270_270 = 5,
    TRTCVideoResolution_480_480 = 7,
    TRTCVideoResolution_160_120 = 50,
    TRTCVideoResolution_240_180 = 52,
    TRTCVideoResolution_280_210 = 54,
    TRTCVideoResolution_320_240 = 56,
    TRTCVideoResolution_400_300 = 58,
    TRTCVideoResolution_480_360 = 60,
    TRTCVideoResolution_640_480 = 62,
    TRTCVideoResolution_960_720 = 64,
    TRTCVideoResolution_160_90 = 100,
    TRTCVideoResolution_256_144 = 102,
    TRTCVideoResolution_320_180 = 104,
    TRTCVideoResolution_480_270 = 106,
    TRTCVideoResolution_640_360 = 108,
    TRTCVideoResolution_960_540 = 110,
    TRTCVideoResolution_1280_720 = 112,
    TRTCVideoResolution_1920_1080 = 114
}
declare enum TRTCVideoStreamType {
    TRTCVideoStreamTypeBig = 0,
    TRTCVideoStreamTypeSmall = 1,
    TRTCVideoStreamTypeSub = 2
}
declare enum TRTCVideoFillMode {
    TRTCVideoFillMode_Fill = 0,
    TRTCVideoFillMode_Fit = 1
}
declare enum TRTCVideoMirrorType {
    TRTCVideoMirrorType_Auto = 0,
    TRTCVideoMirrorType_Enable = 1,
    TRTCVideoMirrorType_Disable = 2
}
declare enum TRTCBeautyStyle {
    TRTCBeautyStyleSmooth = 0,
    TRTCBeautyStyleNature = 1
}
declare enum TRTCAppScene {
    TRTCAppSceneVideoCall = 0,
    TRTCAppSceneLIVE = 1,
    TRTCAppSceneAudioCall = 2,
    TRTCAppSceneVoiceChatRoom = 3
}
declare enum TRTCRoleType {
    TRTCRoleAnchor = 20,
    TRTCRoleAudience = 21
}
declare enum TRTCAudioQuality {
    TRTCAudioQualityDefault = 0,
    TRTCAudioQualitySpeech = 1,
    TRTCAudioQualityMusic = 3
}
/**
 * 设备信息<br>
 * @param {String} deviceId   - 设备PID，字符编码格式是UTF-8
 * @param {String} deviceName - 设备名称，字符编码格式是UTF-8
 * @param {String} kind   - 设备类型，['videoinput' | 'audioinput']
 * @param {String} deviceName - 设备名称，字符编码格式是UTF-8
 */
declare class TRTCDeviceInfo {
    deviceId: string;
    deviceName: string;
    kind?: string;
    label?: string;
    groupId?: string;
    constructor(deviceId?: string, deviceName?: string, kind?: string, label?: string, groupId?: string);
}
declare enum TRTCDeviceState {
    TRTCDeviceStateAdd = 0,
    TRTCDeviceStateRemove = 1,
    TRTCDeviceStateActive = 2
}
declare enum TRTCDeviceType {
    TRTCDeviceTypeUnknow = -1,
    TRTCDeviceTypeMic = 0,
    TRTCDeviceTypeSpeaker = 1,
    TRTCDeviceTypeCamera = 2
}
/**
 * 进房相关参数<br>
 * 只有该参数填写正确，才能顺利调用 enterRoom 进入 roomId 所指定的音视频房间。
 * @param {Number}       sdkAppId      - 【字段含义】应用标识（必填），腾讯视频云基于 sdkAppId 完成计费统计。<br>
 *                                       【推荐取值】在腾讯云 [TRTC 控制台](https://console.cloud.tencent.com/rav/) 中创建应用，之后可以在账号信息页面中得到该 ID。<br>
 * @param {String}       userId        - 【字段含义】用户标识（必填）。当前用户的 userId，相当于用户名，UTF-8编码。<br>
 *                                       【推荐取值】如果一个用户在您的账号系统中的 ID 为“abc”，则 userId 即可设置为“abc”。<br>
 * @param {String}       userSig       - 【字段含义】用户签名（必填），当前 userId 对应的验证签名，相当于登录密码。<br>
 *                                       【推荐取值】请参考 [如何计算UserSig](https://cloud.tencent.com/document/product/647/17275)。<br>
 * @param {Number}       roomId        - 【字段含义】房间号码（必填），指定房间号，在同一个房间里的用户（userId）可以彼此看到对方并进行视频通话, roomId 和 strRoomId 必须填一个, 若您选用 strRoomId，则 roomId 需要填写为0。<br>
 *                                       【推荐取值】您可以随意指定，但请不要重复，如果您的用户账号 ID 是数字类型的，可以直接用创建者的用户 ID 作为 roomId。<br>
 * @param {String}       strRoomId     - 【字段含义】字符串房间号码（选填），roomId 和 strRoomId 必须填一个。若两者都填，则优先选择 roomId。<br>
 *                                       【推荐取值】您可以随意指定，但请不要重复。<br>
 * @param {TRTCRoleType} role          - 【字段含义】直播场景下的角色，仅适用于直播场景（TRTCAppSceneLIVE 和 TRTCAppSceneVoiceChatRoom），视频通话场景下指定无效。<br>
 *                                       【推荐取值】默认值：主播（TRTCRoleAnchor）<br>
 * @param {String}       privateMapKey - 【字段含义】房间签名（非必填），如果您希望某个房间只能让特定的某些 userId 进入，就需要使用 privateMapKey 进行权限保护。<br>
 *                                       【推荐取值】仅建议有高级别安全需求的客户使用，参考文档：[进房权限保护](https://cloud.tencent.com/document/product/647/32240)<br>
 * @param {String}       businessInfo  - 【字段含义】业务数据（非必填），某些非常用的高级特性才需要用到此字段。<br>
 *                                       【推荐取值】不建议使用<br>
 * @param {String}       streamId      - 【字段含义】绑定腾讯云直播 CDN 流 ID[非必填]，设置之后，您就可以在腾讯云直播 CDN 上通过标准直播方案（FLV或HLS）播放该用户的音视频流。<br>
 *                                       【推荐取值】限制长度为64字节，可以不填写，一种推荐的方案是使用 “sdkappid_roomid_userid_main” 作为 streamid，这样比较好辨认且不会在您的多个应用中发生冲突。<br>
 *                                       【特殊说明】要使用腾讯云直播 CDN，您需要先在[控制台](https://console.cloud.tencent.com/trtc/) 中的功能配置页开启“启动自动旁路直播”开关。<br>
 *                                       【参考文档】[CDN 旁路直播](https://cloud.tencent.com/document/product/647/16826)。
 * @param {String}       userDefineRecordId - 【字段含义】设置云端录制完成后的回调消息中的 "userdefinerecordid"  字段内容，便于您更方便的识别录制回调。<br>
 *                                            【推荐取值】限制长度为64字节，只允许包含大小写英文字母（a-zA-Z）、数字（0-9）及下划线和连词符。<br>
 *                                            【参考文档】[云端录制](https://cloud.tencent.com/document/product/647/16823)。
 */
declare class TRTCParams {
    sdkAppId: number;
    userId: string;
    userSig: string;
    roomId: number;
    strRoomId: string;
    role: number;
    privateMapKey: null | string;
    streamId: null | string;
    userDefineRecordId: null | string;
    frameWorkType: number;
    constructor(sdkAppId?: number, userId?: string, userSig?: string, roomId?: number, strRoomId?: string, role?: TRTCRoleType, privateMapKey?: null | string, businessInfo?: null | string, streamId?: null | string, userDefineRecordId?: null | string, frameWorkType?: number);
}
/**
 * 视频编码参数<br>
 * 该设置决定了远端用户看到的画面质量（同时也是云端录制出的视频文件的画面质量）。
 * @param {TRTCVideoResolution}     videoResolution - 【字段含义】 视频分辨率<br>
 *                                                    【推荐取值】 <br>
 *                                                     - 视频通话建议选择360 × 640及以下分辨率，resMode 选择 Portrait。<br>
 *                                                     - 手机直播建议选择 540 × 960，resMode 选择 Portrait。<br>
 *                                                     - Window 和 iMac 建议选择 640 × 360 及以上分辨率，resMode 选择 Landscape。
 *                                                    【特别说明】 TRTCVideoResolution 默认只能横屏模式的分辨率，例如640 × 360。<br>
 *                                                                如需使用竖屏分辨率，请指定 resMode 为 Portrait，例如640 × 360结合 Portrait 则为360 × 640。<br>
 * @param {Number}                  videoFps        - 【字段含义】视频采集帧率<br>
 *                                                    【推荐取值】15fps 或 20fps，10fps 以下会有轻微卡顿感，5fps 以下卡顿感明显，20fps 以上的帧率则过于浪费（电影的帧率也只有 24fps）。<br>
 *                                                    【特别说明】很多 Android 手机的前置摄像头并不支持15fps以上的采集帧率，部分过于突出美颜功能的 Android 手机前置摄像头的采集帧率可能低于10fps。<br>
 * @param {Number}                  videoBitrate    - 【字段含义】视频上行码率<br>
 *                                                    【推荐取值】推荐设置请参考本文件前半部分 TRTCVideoResolution 定义处的注释说明<br>
 *                                                    【特别说明】码率太低会导致视频中有很多的马赛克<br>
 */
declare class TRTCVideoEncParam {
    videoResolution: TRTCVideoResolution;
    videoFps: number;
    videoBitrate: number;
    constructor(videoResolution?: TRTCVideoResolution, videoFps?: number, videoBitrate?: number);
}
declare enum TRTCVideoRotation {
    TRTCVideoRotation0 = 0,
    TRTCVideoRotation90 = 1,
    TRTCVideoRotation180 = 2,
    TRTCVideoRotation270 = 3
}
/**
 * 画面渲染参数<br>
 * 您可以通过设置此参数来控制画面的旋转、填充、镜像模式
 * @param {TRTCVideoRotation} rotation  - 【字段含义】视频画面旋转方向
 * @param {TRTCVideoFillMode} fillMode  - 【字段含义】视频画面填充模式
 * @param {TRTCVideoMirrorType} mirrorType  - 【字段含义】画面渲染镜像类型
 */
declare class TRTCRenderParams {
    rotation: TRTCVideoRotation;
    fillMode: TRTCVideoFillMode;
    mirrorType: TRTCVideoMirrorType;
    constructor(rotation?: TRTCVideoRotation, fillMode?: TRTCVideoFillMode, mirrorType?: TRTCVideoMirrorType);
}
declare enum TRTCQuality {
    TRTCQuality_Unknown = 0,
    TRTCQuality_Excellent = 1,
    TRTCQuality_Good = 2,
    TRTCQuality_Poor = 3,
    TRTCQuality_Bad = 4,
    TRTCQuality_Vbad = 5,
    TRTCQuality_Down = 6
}
/**
 * 网络质量<br>
 * 表示视频质量的好坏，通过这个数值，您可以在 UI 界面上用图标表征 userId 的通话线路质量
 * @param {String}      userId  - 用户标识
 * @param {TRTCQuality} quality - 视频质量
 */
declare class TRTCQualityInfo {
    userId: string;
    quality: TRTCQuality;
    constructor(userId?: string, quality?: TRTCQuality);
}
/**
 * 音量大小<br>
 * 表示语音音量的评估大小，通过这个数值，您可以在 UI 界面上用图标表征 userId 是否有在说话。
 * @param {String} userId - 说话者的 userId，字符编码格式是 UTF-8
 * @param {Number} volume - 说话者的音量， 取值范围0 - 100
 */
declare class TRTCVolumeInfo {
    userId: string;
    volume: number;
    constructor(userId?: string, volume?: number);
}
/**
 * CDN 旁路推流参数<br>
 * @param {Number} appId - 腾讯云 AppID，请在 [实时音视频控制台](https://console.cloud.tencent.com/rav) 选择已经创建的应用，单击【帐号信息】后，在“直播信息”中获取
 * @param {Number} bizId - 腾讯云直播 bizId，请在 [实时音视频控制台](https://console.cloud.tencent.com/rav) 选择已经创建的应用，单击【帐号信息】后，在“直播信息”中获取
 * @param {String} url - 旁路转推的 URL
 */
declare class TRTCPublishCDNParam {
    appId: number;
    bizId: number;
    url: null | string;
    constructor(appId?: number, bizId?: number, url?: null | string);
}
/**
 * 本地的音视频统计信息<br>
 * @param {Number} width           - 视频宽度
 * @param {Number} height          - 视频高度
 * @param {Number} frameRate       - 帧率（fps）
 * @param {Number} videoBitrate    - 视频发送码率（Kbps）
 * @param {Number} audioSampleRate - 音频采样率（Hz）
 * @param {Number} audioBitrate    - 音频发送码率（Kbps）
 * @param {TRTCVideoStreamType} streamType - 流类型（大画面 | 小画面 | 辅路画面）
 */
declare class TRTCLocalStatistics {
    width: number;
    height: number;
    frameRate: number;
    videoBitrate: number;
    audioSampleRate: number;
    audioBitrate: number;
    streamType: TRTCVideoStreamType;
    constructor(width?: number, height?: number, frameRate?: number, videoBitrate?: number, audioSampleRate?: number, audioBitrate?: number, streamType?: TRTCVideoStreamType);
}
/**
 * 统计数据<br>
 * @param {Number} upLoss    - C -> S 上行丢包率（％），这个值越小越好，例如，0%的丢包率代表网络很好，
 *                             而 30% 的丢包率则意味着 SDK 向服务器发送的每10个数据包中就会有3个会在上行传输中丢失。
 * @param {Number} downLoss  - S -> C 下行丢包率（％），这个值越小越好，例如，0%的丢包率代表网络很好，
 *                             而 30% 的丢包率则意味着服务器向 SDK 发送的每10个数据包中就会有3个会在下行传输中丢失。
 * @param {Number} appCpu    - 当前 App 的 CPU 使用率（％）
 * @param {Number} systemCpu - 当前系统的 CPU 使用率（％）
 * @param {Number} rtt       - 延迟（毫秒），代表 SDK 跟服务器一来一回之间所消耗的时间，这个值越小越好。
 *                             一般低于50ms的 rtt 是比较理想的情况，而高于100ms的 rtt 会引入较大的通话延时。
 *                             由于数据上下行共享一条网络连接，所以 local 和 remote 的 rtt 相同。
 * @param {Number} receivedBytes - 总接收字节数（包含信令和音视频）
 * @param {Number} sentBytes     - 总发送字节总数（包含信令和音视频）
 * @param {TRTCLocalStatistics[]} localStatisticsArray - 自己本地的音视频统计信息，由于可能有大画面、小画面以及辅路画面等多路的情况，所以是一个数组
 * @param {Number} localStatisticsArraySize - 数组 localStatisticsArray 的大小
 * @param {TRTCRemoteStatistics[]} remoteStatisticsArray - 远端成员的音视频统计信息，由于可能有大画面、小画面以及辅路画面等多路的情况，所以是一个数组
 * @param {Number} remoteStatisticsArraySize - 数组 remoteStatisticsArray 的大小
 */
declare class TRTCStatistics {
    upLoss: number;
    downLoss: number;
    appCpu: number;
    systemCpu: number;
    rtt: number;
    receivedBytes: number;
    sentBytes: number;
    localStatisticsArray: TRTCLocalStatistics[];
    localStatisticsArraySize: number;
    remoteStatisticsArraySize: number;
    constructor(upLoss?: number, downLoss?: number, appCpu?: number, systemCpu?: number, rtt?: number, receivedBytes?: number, sentBytes?: number, localStatisticsArray?: TRTCLocalStatistics[], localStatisticsArraySize?: number, remoteStatisticsArraySize?: number);
}
declare enum TRTCVideoResolutionMode {
    TRTCVideoResolutionModeLandscape = 0,
    TRTCVideoResolutionModePortrait = 1
}
/**
 * 画质偏好<br>
 * 指当 TRTC SDK 在遇到弱网络环境时，您是希望“保清晰”还是“保流畅”：<br>
 * - Smooth：弱网下保流畅，在遭遇弱网环境时首先确保声音的流畅和优先发送，画面会变得模糊且会有较多马赛克，但可以保持流畅不卡顿。
 * - Clear：弱网下保清晰，在遭遇弱网环境时，画面会尽可能保持清晰，但可能会更容易出现卡顿。
 * @enum {Number}
 */
declare enum TRTCVideoQosPreference {
    TRTCVideoQosPreferenceSmooth = 1,
    TRTCVideoQosPreferenceClear = 2
}
/**
 * 流控模式<br>
 * TRTC SDK 内部需要时刻根据网络情况调整内部的编解码器和网络模块，以便能够对网络的变化做出反应。<br>
 * 为了支持快速算法升级，SDK 内部设置了两种不同的流控模式：
 * - ModeClient： 本地控制，用于 SDK 开发内部调试，客户请勿使用。
 * - ModeServer： 云端控制，推荐模式，也是默认默认。
 * > 推荐您使用云端控制，这样每当我们升级 Qos 算法时，您无需升级 SDK 即可体验更好的效果。
 * @enum {Number}
 */
declare enum TRTCQosControlMode {
    TRTCQosControlModeClient = 0,
    TRTCQosControlModeServer = 1
}
/**
 * 网络流控相关参数<br>
 * 网络流控相关参数，该设置决定了SDK在各种网络环境下的调控方向（比如弱网下是“保清晰”还是“保流畅”）
 * @param {TRTCVideoQosPreference} preference  - 【字段含义】弱网下是“保清晰”还是“保流畅”<br>
 *                                               【特别说明】<br>
 *                                                - 弱网下保流畅：在遭遇弱网环境时，画面会变得模糊，且会有较多马赛克，但可以保持流畅不卡顿
 *                                                - 弱网下保清晰：在遭遇弱网环境时，画面会尽可能保持清晰，但可能会更容易出现卡顿
 * @param {TRTCQosControlMode}     controlMode - 【字段含义】流控模式（云端控制 - 客户端控制）<br>
 *                                               【推荐取值】云端控制<br>
 *                                               【特别说明】<br>
 *                                                - Client 模式：客户端控制模式，用于 SDK 开发内部调试，客户请勿使用
 *                                                - Server 模式（默认）：云端控制模式，若没有特殊原因，请直接使用该模式
 *
 */
declare class TRTCNetworkQosParam {
    preference: TRTCVideoQosPreference;
    controlMode: TRTCQosControlMode;
    constructor(preference?: TRTCVideoQosPreference, controlMode?: TRTCQosControlMode);
}
/**
* 图缓存<br>
* @param {ArrayBuffer} buffer - 图内容
* @param {Number}      length - 图缓存大小
* @param {Number}      width  - 图宽
* @param {Number}      heigth - 图高
*/
declare class TRTCImageBuffer {
    buffer: ArrayBuffer;
    length: number;
    width: number;
    height: number;
    constructor(buffer?: ArrayBuffer, length?: number, width?: number, height?: number);
}
declare enum TRTCLogLevel {
    TRTCLogLevelVerbose = 0,
    TRTCLogLevelDebug = 1,
    TRTCLogLevelInfo = 2,
    TRTCLogLevelWarn = 3,
    TRTCLogLevelError = 4,
    TRTCLogLevelFatal = 5,
    TRTCLogLevelNone = 6
}
/**
 * 屏幕分享目标信息<br>
 * @enum {Number}
 */
declare enum TRTCScreenCaptureSourceType {
    TRTCScreenCaptureSourceTypeUnknown = -1,
    TRTCScreenCaptureSourceTypeWindow = 0,
    TRTCScreenCaptureSourceTypeScreen = 1,
    TRTCScreenCaptureSourceTypeCustom = 2
}
/**
* 屏幕采集源信息<br>
* @param {TRTCScreenCaptureSourceType} type       - 采集源类型
* @param {String}                      sourceId   - 采集源ID；对于窗口，该字段指示窗口句柄；对于屏幕，该字段指示屏幕ID
* @param {String}                      sourceName - 采集源名称，UTF8编码
* @param {TRTCImageBuffer}             thumbBGRA  - 缩略图内容
* @param {TRTCImageBuffer}             iconBGRA   - 图标内容
* @param {Boolean}                     isMinimizeWindow - 是否最小化窗口
*/
declare class TRTCScreenCaptureSourceInfo {
    type: number;
    sourceId: string;
    sourceName: string;
    thumbBGRA: TRTCImageBuffer;
    iconBGRA: TRTCImageBuffer;
    isMinimizeWindow: boolean;
    constructor(type?: TRTCScreenCaptureSourceType, sourceId?: string, sourceName?: string, thumbBGRA?: TRTCImageBuffer, iconBGRA?: TRTCImageBuffer, isMinimizeWindow?: boolean);
}
/**
 * 记录矩形的四个点坐标<br>
 * @param {Number} left   - 左坐标
 * @param {Number} top    - 上坐标
 * @param {Number} right  - 右坐标
 * @param {Number} bottom - 下坐标
 */
declare class Rect {
    left: number;
    top: number;
    right: number;
    bottom: number;
    constructor(left?: number, top?: number, right?: number, bottom?: number);
}
/**
 * 5.13 云端混流（转码）配置
 *
 * 包括最终编码质量和各路画面的摆放位置
 *
 * @param {TRTCTranscodingConfigMode} mode - 【字段含义】转码 config 模式
 * @param {Number} appId - 【字段含义】腾讯云直播 AppID<br>
 *                         【推荐取值】请在 [实时音视频控制台](https://console.cloud.tencent.com/rav) 选择已经创建的应用，单击【帐号信息】后，在“直播信息”中获取
 * @param {Number} bizId - 【字段含义】腾讯云直播 bizid<br>
 *                         【推荐取值】请在 [实时音视频控制台](https://console.cloud.tencent.com/rav) 选择已经创建的应用，单击【帐号信息】后，在“直播信息”中获取
 * @param {Number} videoWidth   - 【字段含义】最终转码后的视频分辨率的宽度。<br>
 *                                【推荐取值】推荐值：360px ，如果你是纯音频推流，请将 width × height 设为 0px × 0px，否则混流后会携带一条画布背景的视频流。
 * @param {Number} videoHeight  - 【字段含义】最终转码后的视频分辨率的高度。<br>
 *                                【推荐取值】推荐值：640px ，如果你是纯音频推流，请将 width × height 设为 0px × 0px，否则混流后会携带一条画布背景的视频流。
 * @param {Number} videoBitrate - 【字段含义】最终转码后的视频分辨率的码率（kbps）<br>
 *                                【推荐取值】如果填0，后台会根据videoWidth和videoHeight来估算码率，您也可以参考枚举定义TRTCVideoResolution_640_480的注释。
 * @param {Number} videoFramerate  - 【字段含义】最终转码后的视频分辨率的帧率（FPS）<br>
 *                                   【推荐取值】默认值：15fps，取值范围是 (0,30]。
 * @param {Number} videoGOP        - 【字段含义】最终转码后的视频分辨率的关键帧间隔（又称为 GOP）。<br>
 *                                   【推荐取值】默认值：2，单位为秒，取值范围是 [1,8]。
 * @param {Number} backgroundColor - 【字段含义】混合后画面的底色颜色，默认为黑色，格式为十六进制数字，比如：“0x61B9F1” 代表 RGB 分别为(97,158,241)。<br>
 *                                   【推荐取值】默认值：0x000000，黑色
 * @param {String} backgroundImage - 【字段含义】混合后画面的背景图。<br>
 *                                   【推荐取值】默认值：''，即不设置背景图<br>
 *                                   【特别说明】背景图需要您事先在 “[控制台](https://console.cloud.tencent.com/trtc) => 应用管理 => 功能配置 => 素材管理” 中上传，<br>
 *                                    上传成功后可以获得对应的“图片ID”，然后将“图片ID”转换成字符串类型并设置到 backgroundImage 里即可。<br>
 *                                    例如：假设“图片ID” 为 63，可以设置 backgroundImage = @"63";
 * @param {Number} audioSampleRate - 【字段含义】最终转码后的音频采样率。<br>
 *                                   【推荐取值】默认值：48000Hz。支持12000HZ、16000HZ、22050HZ、24000HZ、32000HZ、44100HZ、48000HZ。
 * @param {Number} audioBitrate    - 【字段含义】最终转码后的音频码率。<br>
 *                                   【推荐取值】默认值：64kbps，取值范围是 [32，192]。
 * @param {Number} audioChannels   - 【字段含义】最终转码后的音频声道数<br>
 *                                   【推荐取值】默认值：1。取值范围为 [1,2] 中的整型。
 * @param {TRTCMixUser[]} mixUsersArray - 【字段含义】每一路子画面的位置信息
 * @param {String} streamId        - 【字段含义】输出到 CDN 上的直播流 ID。<br>
 *                                    如不设置该参数，SDK 会执行默认逻辑，即房间里的多路流会混合到该接口调用者的视频流上，也就是 A+B =>A；<br>
 *                                    如果设置该参数，SDK 会将房间里的多路流混合到您指定的直播流 ID 上，也就是 A+B =>C。<br>
 *                                   【推荐取值】默认值：''，即房间里的多路流会混合到该接口调用者的视频流上。
 */
declare class TRTCTranscodingConfig {
    mode: TRTCTranscodingConfigMode;
    appId: number;
    bizId: number;
    videoWidth: number;
    videoHeight: number;
    videoBitrate: number;
    videoFramerate: number;
    videoGOP: number;
    backgroundColor: number;
    backgroundImage: string;
    audioSampleRate: number;
    audioBitrate: number;
    audioChannels: number;
    mixUsersArray: TRTCMixUser[];
    mixUsersArraySize: number;
    streamId: string;
    constructor(mode?: TRTCTranscodingConfigMode, appId?: number, bizId?: number, videoWidth?: number, videoHeight?: number, videoBitrate?: number, videoFramerate?: number, videoGOP?: number, backgroundColor?: number, backgroundImage?: string, audioSampleRate?: number, audioBitrate?: number, audioChannels?: number, mixUsersArray?: never[], streamId?: string);
}
declare enum TRTCTranscodingConfigMode {
    TRTCTranscodingConfigMode_Unknown = 0,
    TRTCTranscodingConfigMode_Manual = 1,
    TRTCTranscodingConfigMode_Template_PureAudio = 2,
    TRTCTranscodingConfigMode_Template_PresetLayout = 3,
    TRTCTranscodingConfigMode_Template_ScreenSharing = 4,
    TRTC_TranscodingConfigMode_Unknown = 5,
    TRTC_TranscodingConfigMode_Manual = 6,
    TRTC_TranscodingConfigMode_Template_PureAudio = 7,
    TRTC_TranscodingConfigMode_Template_PresetLayout = 8,
    TRTC_TranscodingConfigMode_Template_ScreenSharing = 9
}
/**
 * 5.9 云端混流中每一路子画面的位置信息
 *
 * TRTCMixUser 用于指定每一路（即每一个 userId）视频画面的具体摆放位置
 *
 * @param {String}              userId      - 参与混流的 userId
 * @param {String}              roomId      - 参与混流的 roomId，跨房流传入的实际 roomId，当前房间流传入 roomId = ''
 * @param {Rect}                rect        - 图层位置坐标以及大小，左上角为坐标原点(0,0) （绝对像素值）
 * @param {Number}              rect.left   - 图层位置的左坐标
 * @param {Number}              rect.top    - 图层位置的上坐标
 * @param {Number}              rect.right  - 图层位置的右坐标
 * @param {Number}              rect.bottom - 图层位置的下坐标
 * @param {Number}              zOrder      - 图层层次（1 - 15）不可重复
 * @param {Boolean}             pureAudio   - 是否纯音频
 * @param {TRTCVideoStreamType} streamType  - 参与混合的是主路画面（TRTCVideoStreamTypeBig）或屏幕分享（TRTCVideoStreamTypeSub）画面
 * @param {TRTCMixInputType}    inputType   - 指定该路流的混合内容（只混合音频、只混合视频、混合音频和视频），该字段是对 pureAudio 字段的升级。
 *                                            默认值：TRTCMixInputTypeUndefined，代表参考 pureAudio 的取值。
 *                                            如果您是第一次使用 TRTC，之前并没有对 pureAudio 字段进行过设置，您可以根据实际需要设置该字段，不建议您再设置 pureAudio。
 *                                            如果您之前在老版本中已经使用了 pureAudio 字段，并期望保持其设置，则可以将 inputType 设置为 TRTCMixInputTypeUndefined。
 * @param {Number}              renderMode  - 该画面在输出时的显示模式。默认值：视频流默认为0。0为裁剪，1为缩放，2为缩放并显示黑底。
 *
 */
declare class TRTCMixUser {
    userId: string;
    roomId: string;
    rect: null | Rect;
    zOrder: number;
    pureAudio: boolean;
    streamType: TRTCVideoStreamType;
    inputType: TRTCMixInputType;
    renderMode: Number;
    constructor(userId?: string, roomId?: string, rect?: null | Rect, zOrder?: number, pureAudio?: boolean, streamType?: TRTCVideoStreamType, inputType?: TRTCMixInputType, renderMode?: number);
}
declare enum TRTCMixInputType {
    TRTCMixInputTypeUndefined = 0,
    TRTCMixInputTypeAudioVideo = 1,
    TRTCMixInputTypePureVideo = 2,
    TRTCMixInputTypePureAudio = 3
}

/**
 * TUIRoomEngine 提供了音视频房间的能力
 *
 * @class TUIRoomEngine
 */
declare class TUIRoomEngine {
    static className: string;
    private static isReady;
    private roomEngineWASM;
    private deviceManager;
    private deviceManagerWASM;
    private trtcCloud;
    private conferenceListManager;
    private conferenceInvitationManager;
    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();
    wxMessageChannel(key: string, value: unknown): void;
    /**
     * @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>} options.view 本地视频流的渲染位置
     * @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>;
    /**
     * 发送自定义消息
     * @param {object} options
     * @deprecated 该接口自 v2.0.0 版本废弃，请使用 {@link getTIM} 方法获取 tim 实例发送消息
     * @param {string} options.messageText 自定义消息内容
     * @returns {Promise<void>}
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.sendCustomMessage({
     *  messageText: '{ data:'', description: ''}',
     * });
     */
    sendCustomMessage(options: {
        messageText: 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;
    /**
     * 获取摄像头设备列表<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<never[]>;
    /**
     * 获取麦克风设备列表<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<never[]>;
    /**
     * 获取扬声器设备列表<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<never[]>;
    /**
     * 设置要使用的摄像头设备<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(): any;
    /**
     * 获取当前正在使用的麦克风设备
     * @returns {TRTCDeviceInfo} 设备信息，能获取设备 ID 和设备名称
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const currentMicDevice = roomEngine.getCurrentMicDevice();
     */
    getCurrentMicDevice(): any;
    /**
     * 获取当前正在使用的扬声器设备
     * @returns {TRTCDeviceInfo} 设备信息，能获取设备 ID 和设备名称
     * @example
     * const roomEngine = new TUIRoomEngine();
     * const currentSpeakerDevice = roomEngine.getCurrentSpeakerDevice();
     */
    getCurrentSpeakerDevice(): any;
    /**
     * 开始进行摄像头测试
     * @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 麦克风音量的回调时间
     *
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.startMicDeviceTest({interval: 200});
     */
    startMicDeviceTest(options: {
        interval: number;
    }): Promise<void>;
    /**
     * 停止进行麦克风测试
     * @example
     * const roomEngine = new TUIRoomEngine();
     * await roomEngine.stopMicDeviceTest();
     */
    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;
    /**
     * 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 { Rect, TRTCAppScene, TRTCAudioQuality, TRTCBeautyStyle, TRTCDeviceInfo, TRTCDeviceState, TRTCDeviceType, TRTCImageBuffer, TRTCLocalStatistics, TRTCLogLevel, TRTCMixInputType, TRTCMixUser, TRTCNetworkQosParam, TRTCParams, TRTCPublishCDNParam, TRTCQosControlMode, TRTCQuality, TRTCQualityInfo, TRTCRenderParams, TRTCRole, TRTCRoleType, TRTCScreenCaptureSourceInfo, TRTCScreenCaptureSourceType, TRTCStatistics, TRTCTranscodingConfig, TRTCTranscodingConfigMode, TRTCVideoEncParam, TRTCVideoFillMode, TRTCVideoMirrorType, TRTCVideoQosPreference, TRTCVideoResolution, TRTCVideoResolutionMode, TRTCVideoRotation, TRTCVideoStreamType, TRTCVolumeInfo, TUIAudioQuality, TUIAudioRoute, TUICaptureSourceType, TUIChangeReason, TUIConferenceCancelReason, type TUIConferenceInfo, TUIConferenceInvitationManager, TUIConferenceInvitationManagerEvents, TUIConferenceListManager, TUIConferenceListManagerEvents, type TUIConferenceModifyInfo, TUIConferenceStatus, type TUIDeviceInfo, type TUIEnterRoomOptions, TUIErrorCode, type TUIInvitation, TUIInvitationCode, TUIInvitationRejectedReason, TUIInvitationStatus, TUIKickedOutOfRoomReason, type TUILoginUserInfo, TUIMediaDevice, TUIMediaDeviceState, TUIMediaDeviceType, type TUIMessage, type TUINetwork, TUINetworkQuality, type TUIRequest, TUIRequestAction, type TUIRequestCallback, TUIRequestCallbackType, TUIResolutionMode, TUIRole, TUIRoomDeviceManager, TUIRoomDeviceMangerEvents, TUIRoomDismissedReason, TUIRoomEngine, TUIRoomEvents, type TUIRoomInfo, TUIRoomType, type TUISeatInfo, type TUISeatLockParams, TUISeatMode, type TUIUserInfo, type TUIVideoEncoderParams, TUIVideoQuality, TUIVideoStreamType, TUIRoomEngine as default };