client 详述

client.toggleLocal(): Promise<{ status: boolean }

client.setVideoRenderer(key: string, wrapEleId: string): void

client.setAudioRenderer(key: string, wrapEleId: string): void

client.switchAutoDevice(status: boolean): Promise<boolean>

client.switchLayout(templateMode?: IMode): Promise<IMode>;

/**
 * 布局模式
 */
type IMode = ITemplateMode | IContentTemplateMode;
                    
/**
 * Layout布局方式
 *
 * @value SPEAKER 默认值，演讲者模式，即 1大N小 画面模式
 * @value GALLERY 另一种是画廊模式，即 宫格布局
 */
type ITemplateMode = 'SPEAKER' | 'GALLERY';

/**
 * 主画面/Content布局模式
 *
 * @value MULTI_PIC_CONTENT_HIGH_PRIORITY Content是大窗口
 * @value MULTI_PIC_ACTIVE_HIGH_PRIORITY ActiveSpecker是大窗口
 * @value TWO_PIC_PIP 画中画模式(picture in picture)
 * @value CONTENT_ONLY 只显示Content
 * @value TWO_PIC_SYMMETRIC 对称显示content和speker(side by side)
 */
type IContentTemplateMode =
  | 'MULTI_PIC_CONTENT_HIGH_PRIORITY'
  | 'MULTI_PIC_ACTIVE_HIGH_PRIORITY'
  | 'TWO_PIC_PIP'
  | 'CONTENT_ONLY'
  | 'TWO_PIC_SYMMETRIC';

client.makeCall(data: IMackCall): Promise<Boolean>;

/**
 * 呼叫参数
 *
 * @property { string } token 网关token
 * @property { string } confNumber 云会议号/终端号/手机号
 * @property { string? } password 入会密码，没有则为空
 * @property { string? } displayName 入会显示昵称
 * @property { boolean } muteAudio 非必填 | false | 是否开启/关闭麦克风入会，默认是false，开启麦克风
 * @property { boolean } muteVideo 非必填 | false | 是否开启/关闭摄像头入会，默认是false，开启摄像头
 */
interface IMackCall {
  token: string;
  // 云会议号
  // v2.0.2+版本支持呼叫硬件终端号码、手机号
  // v2.1.1+版本支持呼叫H323会议/硬件
  confNumber: string;
  password?: string;
  displayName?: string;
  // 兼容 v3.9.3+
  muteAudio?: boolean;
  // 兼容 v3.9.3+
  muteVideo?: boolean;
}

client.publish(stream: Stream, params: IPublishParams): void;

interface IPublishParams {
  // 是否是推送本地数据流，默认是false，初始入会需要设置为true；
  isSharePeople?: boolean;
  // 是否是推送共享屏幕流，默认是false，不推送，当需要屏幕共享时，请配置为true；
  isShareContent?: boolean;
}

client.stopShareContent(): Promise<Boolean>

client.destroy(): Promise<Boolean>

client.loginXYlinkAccount(userName: string, password: string): Promise<IReturnResult>;

// 成功code：XYSDK:950120
// 失败code详见错误码文档
interface IReturnResult {
  code: number;
  msg: string;
  detail: {} | { access_token: string };
}

XYClient.loginXYAccount(params: LoginXYAccountParams): Promise<IReturnResult>;

/**
 * 三方用户统一认证登录 - 小鱼账号登录 参数
 *
 * @param { string } account - 必填，用户账号
 * @param { string } password - 必填，用户密码
 * @param { string } extId - 必填，企业ID
 * @param { string? } countryCode - 可选，国家码：默认+86
 */
export interface LoginXYAccountParams {
  account: string;
  password: string;
  extId: string;
  countryCode?: string;
}

// 成功code：XYSDK:950120
// 失败code详见错误码文档
interface IReturnResult {
  code: number;
  msg: string;
  detail: {} | { access_token: string };
}

client.loginExternalAccount(params: ILoginExtAccount): Promise<IReturnResult>;

/**
 * 第三方登录用户信息
 *
 * @property { string } displayName - 必填，用户名称
 * @property { string } extId - 必填，企业id
 * @property { string } extUserId - 可选，三方用户ID
 * @property { string } authCode - 可选，授权码
 * @property { boolean } tempUser - 可选，临时账号
 */
interface ILoginExtAccount {
  displayName: string;
  extId: string;
  extUserId?: string;
  authCode?: string;
  tempUser?: boolean;
}

// 成功code：XYSDK:950120
// 失败code详见错误码文档
interface IReturnResult {
  code: number;
  msg: string;
  detail: {} | { access_token: string };
}

XYClient.loginExtToken(params: LoginExtTokenParams): Promise<IReturnResult>;

/**
 * 三方用户统一认证登录 - token登录
 *
 * @param { string } authCode - 必填，登录码
 * @param { string } extId - 必填，企业ID
 */
interface LoginExtTokenParams {
  authCode: string;
  extId: string;
}

// 成功code：XYSDK:950120
// 失败code详见错误码文档
interface IReturnResult {
  code: number;
  msg: string;
  detail: {} | { access_token: string };
}

XYClient.loginWithAuthCode(params: ILoginWidthAuthCode): Promise<IReturnResult>;

/**
 * 授权码登录
 *
 * @property { string } extId - 必填，企业id
 * @property { string } extUserId - 必填，用户id
 * @property { string } displayName - 必填，用户名
 * @property { string } oauthCode - 必填，授权码
 * @property { boolean } isTempUser - 必填，是否是临时账号
 * @property { string } channelId - 必填，渠道id
 */
interface ILoginWidthAuthCode {
  extId: string;
  extUserId: string;
  displayName: string;
  oauthCode: string;
  isTempUser: boolean;
  channelId: string;
}

// 成功code：XYSDK:950120
// 失败code详见错误码文档
interface IReturnResult {
  code: number;
  msg: string;
  detail: {} | { access_token: string };
}

client.muteAudio(): Promise<IVideoAudioType>;

type IVideoAudioType = 'muteAudio' | 'muteVideo' | 'unmuteAudio' | 'unmuteVideo'

client.unmuteAudio(): Promise<IVideoAudioType>;

type IVideoAudioType = 'muteAudio' | 'muteVideo' | 'unmuteAudio' | 'unmuteVideo'

client.muteVideo(): Promise<IVideoAudioType>;

type IVideoAudioType = 'muteAudio' | 'muteVideo' | 'unmuteAudio' | 'unmuteVideo'

client.unmuteVideo(): Promise<IVideoAudioType>;

type IVideoAudioType = 'muteAudio' | 'muteVideo' | 'unmuteAudio' | 'unmuteVideo'

client.onHandUp(): Promise<boolean

client.onHandDown(): Promise<boolean

client.onMute(): Promise<boolean

client.switchDebug(status: boolean): Promise<boolean>

client.requestNewLayout(reqList: IReqInfo[], maxViewCountPerPage: number, pageIndex: number, extReqList: IReqInfo[] = [], extParams?: IExtParams): Promise<boolean>;

interface IReqInfo {
  // 是否是共享内容设备，0：people画面，1：content共享画面；
  mediagroupid: 0 | 1;
  // 设备唯一calluri
  // 没有可以指定为空即可，会按照主会场/语音激励/音视频开启/音频开启/视频开启/关闭的优先级推送远端数据
  calluri: string;
  // 请求当前设备的分辨率数据：
  // 1: 180P
  // 2: 360P
  // 3: 720P people默认最多请720P画面；企业如果配置请求1080P画面的能力，则最多可请1080P的画面
  // 4: 1080P content最多请1080P画面
  resolution: IResolutionType;
  // 0: low 低画面质量，帧率会自动降低到15帧接收；
  // 1: normal 普通画面质量，会基于带宽信息自动在30/15帧切换；
  // 2: high 高画面质量，会优先匹配高帧率高分辨率画面；
  quality: IQualityType;
};

// 如上定义
type IResolutionType = 1 | 2 | 3 | 4 | 5;

// 如上定义
type IQualityType = 0 | 1 | 2;

// 额外的参数
interface IExtParams {
  // 分页查看更多画面时，第一页是否包含Local画面数量，默认是 true，包含Local的数量
  uiShowLocalWhenPageMode: boolean;
}

client.requestLayout(reqList: IReqInfo[]): Promise<string>;

type IReqInfo = {
  // 是否是共享内容设备，可以从roster中的isContent中获取；
  isContent: boolean;
  // 设备id，可以从roster中的endpointId中获取；
  callUri: string;
  // 请求当前设备的分辨率数据：
  // 0: 90P
  // 1: 180P
  // 2: 360P
  // 3: 720P people最多请720P画面
  // 4: 1080P content最多请1080P画面
  resolution: IResolutionType;
  // 0: low 质量较低
  // 1: normal 质量普通
  // 2: high 质量高优先级
  quality: IQualityType;
};

// 如上定义
type IResolutionType = 0 | 1 | 2 | 3 | 4 | 5;

// 如上定义
type IQualityType = 0 | 1 | 2

client.requestAutoPollingLayout(command: TCommand, interval: number = 5, reqList: IReqInfo[]): Promise<boolean>;

// 轮询多画面状态: 0 开始 | 1 停止 | 2 暂停 | 3 恢复
type TCommand = 0 | 1 | 2 | 3;

type IReqInfo = {
  // 是否是共享内容设备，0：people画面，1：content共享画面；
  mediagroupid: 0 | 1;
  // 设备唯一calluri，可以在【custom-layout】事件回调中获取；
  calluri: string;
  // 请求当前设备的分辨率数据：
  // 1: 180P
  // 2: 360P
  // 3: 720P people最多请720P画面
  // 4: 1080P content最多请1080P画面
  resolution: IResolutionType;
  // 0: low 低画面质量，帧率会自动降低到15帧接收；
  // 1: normal 普通画面质量，会基于带宽信息自动在30/15帧切换；
  // 2: high 高画面质量，会优先匹配高帧率高分辨率画面；
  quality: IQualityType;
};

// 如上定义
type IResolutionType = 1 | 2 | 3 | 4 | 5;

// 如上定义
type IQualityType = 0 | 1 | 2;

client.setPageInfo(currentPage)

client.getSelfRoster(): IRoster

 /**
   * 全屏请流
   * 请全屏 设置对应的layout id
   * 退出全屏 可不传参数
   *
   * @param { string } id rosterId
   * @returns Promise<string> rosterId
   */

client.forceFullScreen(id = ''): Promise<string>;

client.on(keyName: string, listenerFunction: () => {}): void

client.off(keyName: string): void

client.subscribeBulkRoster(): Promise<boolean>

client.startTranslation(): Promise<boolean>;

client.stopTranslation(): Promise<boolean>;

client.setTranslationLanguage(language: 'Chinese' | 'English'): Promise<boolean>;

client.startCloudRecord(): void;

client.stopCloudRecord(): void;

client.startMonitorGroup(mediagrpIds: string[] | number[]): boolean;

client.stoMonitorGroup(mediagrpIds: string[] | number[]): boolean;

client.sendCustomMessage(config: ICustomMessageConfig): void;

/**
 * 用户自定义消息
 *
 * @property { number } toPid - 消息的接收方pid，0表示广播消息、非0表示单点消息；
 * @property { string } data - 消息内容，可以被JSON序列化的字符串；因业务数据可能会传输图片，需要进行base64编码，消息最大长度限制：1MB
 */
interface ICustomMessageConfig {
  toPid: number;
  data: string;
}

client.setFeatureConfig(config: IFeatureConfig): void;

/**
 * SDK功能控制开关，用于内部是否启用某些功能的运行
 *
 * @property { boolean } enableMeetingShout 是否启用会控喊话场景，会控喊话场景需要指定mediaGroupId分组通道信息才可以正常接收远端声音；
 * @property { boolean } enableV2States 是否启用小鱼数据上报功能，默认启用，设置为true；
 * @property { boolean } enableCheckRecordPermission 是否启用录制权限查询功能，默认不启用，设置为false；
 * @property { boolean } enableBandwidthSetting 是否启用查询企业带宽配置、允许请求高分辨率配置功能，默认不启用，设置为false；
 * @property { boolean } enableMeetingInvite 是否启用查询小鱼会议邀请链接信息，默认不启用，设置为false；
 * @property { boolean } enableMeetingOwner 是否启用查询会议Owner信息，默认不启用，设置为false;
 * @property { boolean } enableAutoResizeLayout 是否启用自动布局下，当屏幕大小变化后计算最新的Layout数据，默认启用，设置为true;
 * @property { boolean } enableLowResolution 是否启用低性能模式，降低发送和接收端的分辨率和质量，默认不启用，设置为false;
 * @property { boolean } enableSpeakerInfo 是否启用推送实时讲话人信息，每秒2条消息推送，默认不启用，设置为false;
 * @property { boolean } config.enableLayoutAvatar 是否启用获取参会者头像，默认不启用，设置为false;
 * @property { boolean } enableMobileNotAuth 移动端是否支持无授权入会， 默认设置为false;
 */
interface IFeatureConfig {
  enableMeetingShout?: boolean;
  enableV2States?: boolean;
  enableCheckRecordPermission?: boolean;
  enableBandwidthSetting?: boolean;
  enableMeetingInvite?: boolean;
  enableMeetingOwner?: boolean;
  enableAutoResizeLayout?: boolean;
  enableLowResolution?: boolean;
  enableSpeakerInfo?: boolean;
  enableLayoutAvatar?: boolean;
  enableMobileNotAuth?: boolean;
}

client.getConfMgmtUrl(): Promise<IConfMgmtUrl | null>;


/*
 * 会控URL
 *
 * @property { string } pc - 会控桌面端URL
 * @property { string } member - 参会者列表URL
 * @property { string } side - 侧边栏会控URL
 * @property { string } mobile - 会控APP端URL
 * @property { string } professional - 专业会控URL
 */
export interface IConfMgmtUrl {
  pc: string;
  member: string;
  side: string;
  mobile: string;
  professional: string;
}

client.sendVideoControlResult(
    type: 'muteVideo' | 'unMuteVideo',
    data: IVideoControlResult
  ): Promise<IReturnResult>;

/**
 * 上报会控控制开启/关闭摄像头结果
 *
 * @property { boolean } agree - 是否同意开启/关闭摄像头
 * no.camera.permission：终端未授权App摄像头权限
 * reject.unmute.video：参会人拒绝开启摄像头
 * voice.mode：终端在语音模式
 * driving.mode：终端在驾驶模式
 * ''：同意为空即可
 * @property { string } reason - 是否同意开启/关闭摄像头
 * @property { string } requestId - 终端收到的muteVideoQuery/unMuteVideoQuery消息中的requestId
 */
interface IVideoControlResult {
  agree: boolean;
  reason: string;
  requestId: string;
}

/**
 * 返回结果内容
 *
 * @property { string } code - 结果码
 * @property { string } msg - 结果说明
 * @property { any } detail - 数据内容
 */
interface IReturnResult {
  code: string;
  msg: string;
  detail: any;
}

/**
  * 修改参会者名称，暂只支持修改本地名称
  *
  * @param { string } newName - 新名称，支持2-40个字符，仅支持大小写字母、数字、汉字以及空格、特定的表达符号((-_--.))
  */
client.rename (newName: string): Promise<IReturnResult>;


// 新名词正则判断
const allowedCharactersRegex =
  /[\u0041-\u005A\u0061-\u007A\u0030-\u0039\u4E00-\u9FA5\u002e\u002d\u005F\u00e4\u00d6\u00f6\u00dc\u00fc\u1e9e\u00df\u00d1\u00f1\u2014\s]/g;

/**
 * 返回结果内容
 *
 * @property { string } code - 结果码
 * @property { string } msg - 结果说明
 * @property { any } detail - 数据内容
 */
interface IReturnResult {
  code: string;
  msg: string;
  detail: any;
}

client.updateLayoutSize(): void;

/**
  * 切换布局方向
  *
  * @param { LayoutOrientationType } orientation  - 布局方向： MOBILE_HORIZONTAL(横屏)；MOBILE_VERTICAL(竖屏)
  */
client.setLayoutOrientation(orientation: LayoutOrientationType): Promise<IReturnResult>;


/**
 * Layout 移动端布局方向
 *
 * @param NONE -1 - 默认布局(PC)
 * @param MOBILE_HORIZONTAL 0 - 移动端横屏布局
 * @param MOBILE_VERTICAL 1 - 移动端竖屏布局
 */
enum LayoutOrientationType {
    NONE = -1,
    MOBILE_HORIZONTAL = 0,
    MOBILE_VERTICAL = 1
}

  /**
   * trackType 控制发送通道类型，audio控制音频通道，video控制视频通道，暂时只支持audio通道
   * mediagroupId 分组id，也称sessionId或者mediaGroupId，代表只向此分组通道发送音频数据
   */
client.bindTrackGroup(trackType: 'audio' | 'video', mediagroupId: number): boolean | IReturnResult;

interface IReturnResult {
  code: string;
  msg: string;
  detail: any;
}

/**
 * 设置相机方向
 *
 * @param { IFacingMode } position 相机方向
 * @returns { Promise<IFacingMode> } 最终切换的相机方向
 */
client.switchCamera(facingMode?: IFacingMode): Promise<IFacingMode>;
                    
/**
 * 手机相机方向
 *
 * @param FRONT - 前置摄像头
 * @param BACK - 后置摄像头
 */                    
type IFacingMode = 'FRONT' | 'BACK'；

/**
 * 设置会议级别焦点画面
 *
 * @param { string } rosterId - 指定焦点画面的rosterId
 * @returns { Promise<IReturnResult> } - 操作结果
 */
client.startMeetingFocusView(rosterId:string): Promise<IReturnResult>;
                    
/**
 * 返回结果内容
 *
 * @property { string } code - 结果码
 * @property { string } msg - 结果说明
 * @property { any } detail - 数据内容
 */
export interface IReturnResult {
  code: string;
  msg: string;
  detail: any;
}

/**
 * 取消会议级别焦点画面
 *
 * @param { string } rosterId - 取消焦点画面的rosterId
 * @returns { Promise<IReturnResult> } - 操作结果
 */
client.stopMeetingFocusView(rosterId:string): Promise<IReturnResult>;
                    
/**
 * 返回结果内容
 *
 * @property { string } code - 结果码
 * @property { string } msg - 结果说明
 * @property { any } detail - 数据内容
 */
export interface IReturnResult {
  code: string;
  msg: string;
  detail: any;
}

  /**
   * 设置布局相关配置
   *
   * @param { LayoutConfig } config - 配置参数
   * @property { boolean? } config.isForceSharedLayout - 本地共享布局是否强制宫格布局，默认强制，设置为true;
   * @property { number? } config.localSharedMaxViewCount - 本地共享时显示的最大画面数量，默认4画面，最大8画面
   */
client.setLayoutConfig(config: LayoutConfig);
  

/**
 * 布局相关配置
 *
 * @property { boolean } isForceSharedLayout - 本地共享布局是否强制宫格布局
 * @property { number } localSharedMaxViewCount - 本地共享时显示的最大画面数量
 */
export interface LayoutConfig {
  isForceSharedLayout?: boolean;
  localSharedMaxViewCount?: number;
}

client.on("roster", (e: IRoster[]) => {}): void;

interface IRoster {
  // 设备类型
  deviceType: string;
  // 设备Id
  endpointId: string;
  // 名称
  displayName: string;
  // people or content标示，0代表people，1代表Content内容
  mediagroupid: number;
  // 成员pid值
  participantId: number;
  // 当前设备麦克风的状态
  audioTxMute: boolean;
  // 当前设备摄像头状态
  videoTxMute: boolean;
  // 忽略
  audioRxMute: boolean;
  // 忽略
  videoRxMute: boolean;
  // 忽略
  videoMuteReason: number;
  // 是否是主会场
  isForceFullScreen: boolean;
  // 是否是焦点画面 v3.9.4+新增
  isFocusScreen: boolean;
  // 忽略
  isLastAdd: boolean;
  // 是否是呼叫等待状态
  onHold: boolean;
  // 是否正在轮询显示
  isPolling: boolean;
  // 是否是content内容
  isContent: boolean;
  // 是否是Local设备
  isLocal: boolean;
  // 唯一id值 (v3.9.10+ 废弃，使用key)
  id: string;
  // 唯一值 (v3.9.10+ 新增)
  key: string;
  // 是否是activeSpeaker语音激励
  isActiveSpeaker?: boolean;
}

client.on("cancel-handup", (e: boolean) => {}): void

client.on("disconnected", (e: IDisconnected)=> {}): void;

interface IDisconnected {
  code: number;
  msg: string;
  detail: {
    // 退会消息原因
    message: string;
    // 退会消息错误码
    key: string;
  };
}

client.on("error", (e: IResult) => {}): void;

interface IResult {
  // 错误码，详情见错误码表
  code: number;
  // 错误原因
  msg: string;
  // 错误数据内容
  detail: Object;
}

client.on("call-status", (e: IResult) => {}): void;

interface IResult {
  // 错误码，详情见错误码表
  // 存在的状态：
  // 10517：呼叫失败
  // 10518：加入会议成功
  // 10519：正在呼叫中，请等待
  code: number;
  // 错误原因
  msg: string;
  // 错误数据内容
  detail: Object;
}

client.on('layout', (e: ILayout[]) => ())

/**
 * 布局对象
 *
 * @property { string } id - Layout ID, v3.9.10+ 新增
 * @property { IRoster } roster 参会者基本信息、状态信息，例如：用户名、麦克风/摄像头状态、是否是主会场等信息
 * @property { ILayoutState } state 当前参会者的画面状态信息，暂时未使用
 * @property { any } rotate 当前参会者的旋转信息，用于设置video标签样式
 * @property { { left: string; top: string; width: string; height: string } } positionStyle 当前参会者的位置样式
 * @property { string } avatar 人物头像
 * @property { string } textAvatar 名称头像
 * @property { ExternalTemplateConfig } templateConfig 忽略
 * @property { { width: number; height: number } } positionInfo 忽略
 * @property { number[] } position 忽略
 * @property { boolean } deal 忽略
 * @property { number } index 忽略
 * @property { number } resolution 忽略, 2.0.2以前的版本 自定义布局roster请流使用
 * @property { number } quality 忽略, 2.0.2以前的版本 自定义布局roster请流使用
 * @property { AutoState } pollingState 轮询多画面状态
 * @property { string } pollingId - 多画面ID
 * @property { string } pollingName - 多画面名称
 */
interface ILayout {
  id: string; 
  roster: IRoster | null;
  state?: ILayoutState;
  rotate?: any;
  positionStyle?: {
    left: string;
    top: string;
    width: string;
    height: string;
  };
  avatar?: string;
  textAvatar?: string;
  templateConfig?: ExternalTemplateConfig;
  position?: number[];
  positionInfo?: {
    width: number;
    height: number;
  };
  deal?: boolean;
  index?: number;
  resolution?: number;
  quality?: number;
  pollingState?: AutoState;
  pollingId?: string;
  pollingName?: string;
}

/**
 * Roster：参会者的基本信息，包含基本信息，设备信息，画面信息等
 *
 * @property { string } key 内部Key，包含参会者endpointId、多分组通道信息，由一定规则生成；
 * @property { IDeviceType } deviceType 设备类型
 * @property { string } endpointId 设备id
 * @property { string } displayName 参会者名称
 * @property { number } mediagroupid 参会者画面类型，0：people画面，1：共享内容画面
 * @property { number } participantId 参会者id
 * @property { boolean } audioTxMute 参会者麦克风状态，true：开启，false：关闭
 * @property { boolean } videoTxMute 参会者摄像头状态，true：开启，false：关闭
 * @property { boolean } isForceFullScreen 参会者是否是主画面
 * @property { number } videoMuteReason 视频关闭原因
 * @property { boolean } isContent 参会者画面类型，同mediagroupid，true：是共享内容画面，false：people画面
 * @property { boolean } isActiveSpeaker 参会者是否是语音激励，即当前会中说话声音最大的一个人
 * @property { boolean } isLocal 是否是Local设备
 * @property { boolean } audioRxMute ignore
 * @property { boolean } videoRxMute ignore
 * @property { boolean } onHold ignore
 * @property { boolean } isLastAdd ignore
 * @property { boolean } isPolling ignore
 * @property { AutoState } pollingState 轮询多画面状态
 * @property { string } pollingId - 多画面ID
 * @property { string } pollingName - 多画面名称 
 */
interface IRoster extends Partial<ILayoutRoster> {
  key: string;
  deviceType: IDeviceType;
  endpointId: string;
  displayName: string;
  mediagroupid: number;
  participantId: number;
  audioTxMute: boolean;
  videoTxMute: boolean;
  audioRxMute: boolean;
  videoRxMute: boolean;
  videoMuteReason: number;
  isForceFullScreen: boolean;
  isLastAdd: boolean;
  onHold: boolean;
  isPolling: boolean;
  isContent: boolean;
  isActiveSpeaker: boolean;
  isLocal?: boolean;
}

/**
 * Layout Result布局结果中返回的基础数据
 *
 * @property { number } participantId 参会者id
 * @property { 0 | 1 } mediagroupid 参会者画面类型，0：people画面，1：共享内容画面
 * @property { string } remoteType 设备类型
 * @property { string } remoteName 参会者名称
 * @property { string } videoTrackId 当前参会者画面Track轨道id，用于在 VideoTrackList 中匹配stream数据
 * @property { boolean } isAudioMute 参会者麦克风状态，true：开启，false：关闭
 * @property { boolean } isVideoMute 参会者摄像头状态，true：开启，false：关闭
 * @property { boolean } isActiveSpeaker 参会者是否是语音激励，即当前会中说话声音最大的一个人
 * @property { number } LayoutVideoState 参会者画面的状态：请求中，正常，电话入会，视频暂停等
 * @property { number } MuteReason 视频关闭原因
 * @property { number } extUserId 参会者ID
 * @property { string } calluri 参会者Url
 * @property { number } ExpectHeight 期望分辨率
 * @property { number } ExpectWidth 期望分辨率
 * @property { number } feccOri ignore
 */
interface ILayoutRoster {
  participantId: number;
  mediagroupid: number;
  remoteType: string;
  remoteName: string;
  videoTrackId: string;
  isAudioMute: boolean;
  isVideoMute: boolean;
  isActiveSpeaker: boolean;
  LayoutVideoState: number;
  MuteReason: number;
  extUserId: string;
  calluri: string;
  ExpectHeight: number;
  ExpectWidth: number;
  feccOri: number;
}

/**
 * 自动轮询多画面状态
 *
 * @property NORMAL - 画面正常
 * @property NO_JOINED - 未入会
 * @property VIDEO_MUTE - 视频暂停
 * @property NOT_FOUND - 未符合条件的终端
 * @property NULL - 画面为空
 */
enum AutoState {
  'NORMAL' = 'NORMAL',
  'NO_JOINED' = 'NO_JOINED',
  'VIDEO_MUTE' = 'VIDEO_MUTE',
  'NOT_FOUND' = 'NOT_FOUND',
  'NULL' = 'NULL'
}

client.on('screen-info', (e: IScreenInfo) => {}): void;

interface screenInfo {
  // 按照屏幕比例计算得到的Layout容器高度
  rateHeight: number;
  // 按照屏幕比例计算得到的Layout容器宽度
  rateWidth: number;
  // ...其他属性忽略
}

client.on('video-track', (e: ICustomStreamTrack[]) => ());

interface ICustomMediaStream {
  streams: MediaStream[];
  track: MediaStreamTrack;
}

interface ICustomStreamTrack {
  // track类型，是remote or local
  status: string;
  // track stream and track data
  data: RTCTrackEvent | ICustomMediaStream;
  // rest data
  rest: {
    streamId: string;
    trackId: string;
    track: MediaStreamTrack;
  };
}

client.on('audio-track', (e: ICustomStreamTrack[]) => ());

interface ICustomMediaStream {
  streams: MediaStream[];
  track: MediaStreamTrack;
}

interface ICustomStreamTrack {
  // track类型，是remote or local
  status: string;
  // track stream and track data
  data: RTCTrackEvent | ICustomMediaStream;
  // rest data
  rest: {
    streamId: string;
    trackId: string;
    track: MediaStreamTrack;
  };
}

client.on('custom-layout', (e: ICustomLayoutObj[]) => ());

interface ICustomLayoutObj {
  resolution: IResolutionType;
  roster: IRoster;
  rotate: any;
  state: ILayoutState;
  // 100/200是v2.0.2之前的数据格式，之后统一为0/1/2
  quality: 0 | 1 | 2 | 100 | 200;
  deal?: boolean;
  position?: number[];
  positionStyle?: { left?: string; top?: string; width?: string; height?: string };
  positionInfo?: { width?: number; height?: number };
  zIndex?: number;
  // V3.8.0+ 支持上报参会者头像，需通过setFeatureConfig启用获取参会者头像，默认不启用。
  avatar?: string;
}

// audioOnly: 语音通话中
// mute 视频暂停
// request 视频请求中
// normal 视频正常
// invalid 设备不可用
export type ILayoutState =
  | 'MUTE'
  | 'REQUEST'
  | 'NORMAL'
  | 'INVALID'
  | 'AUDIO_TEL'
  | 'AUDIO_ONLY'
  | 'AUDIO_CONTENT';


/**
 * Roster：参会者的基本信息，包含基本信息，设备信息，画面信息等
 *
 * @property { string } id 内部Key，包含参会者endpointId、多分组通道信息，由一定规则生成
 * @property { IDeviceType } deviceType 设备类型
 * @property { string } endpointId 设备id
 * @property { string } displayName 参会者名称
 * @property { number } mediagroupid 参会者画面类型，0：people画面，1：共享内容画面
 * @property { number } participantId 参会者id
 * @property { boolean } audioTxMute 参会者麦克风状态，true：开启，false：关闭
 * @property { boolean } videoTxMute 参会者摄像头状态，true：开启，false：关闭
 * @property { boolean } isForceFullScreen 参会者是否是主画面
 * @property { number } videoMuteReason 视频关闭原因
 * @property { boolean } isContent 参会者画面类型，同mediagroupid，true：是共享内容画面，false：people画面
 * @property { boolean } isActiveSpeaker 参会者是否是语音激励，即当前会中说话声音最大的一个人
 * @property { boolean } isLocal 是否是Local设备
 * @property { boolean } audioRxMute ignore
 * @property { boolean } videoRxMute ignore
 * @property { boolean } onHold ignore
 * @property { boolean } isLastAdd ignore
 * @property { boolean } isPolling ignore
 */
interface IRoster extends Partial<ILayoutRoster> {
  key: string;
  deviceType: IDeviceType;
  endpointId: string;
  displayName: string;
  mediagroupid: number;
  participantId: number;
  audioTxMute: boolean;
  videoTxMute: boolean;
  audioRxMute: boolean;
  videoRxMute: boolean;
  videoMuteReason: number;
  isForceFullScreen: boolean;
  isLastAdd: boolean;
  onHold: boolean;
  isPolling: boolean;
  isContent: boolean;
  isActiveSpeaker: boolean;
  isLocal?: boolean;
}

/**
 * Layout Result布局结果中返回的基础数据
 *
 * @property { number } participantId 参会者id
 * @property { 0 | 1 } mediagroupid 参会者画面类型，0：people画面，1：共享内容画面
 * @property { string } remoteType 设备类型
 * @property { string } remoteName 参会者名称
 * @property { string } videoTrackId 当前参会者画面Track轨道id，用于在 VideoTrackList 中匹配stream数据
 * @property { boolean } isAudioMute 参会者麦克风状态，true：开启，false：关闭
 * @property { boolean } isVideoMute 参会者摄像头状态，true：开启，false：关闭
 * @property { boolean } isActiveSpeaker 参会者是否是语音激励，即当前会中说话声音最大的一个人
 * @property { number } LayoutVideoState 参会者画面的状态：请求中，正常，电话入会，视频暂停等
 * @property { number } MuteReason 视频关闭原因
 * @property { number } extUserId 参会者ID
 * @property { string } calluri 参会者Url
 * @property { number } ExpectHeight 期望分辨率
 * @property { number } ExpectWidth 期望分辨率
 * @property { number } feccOri ignore
 */
interface ILayoutRoster {
  participantId: number;
  mediagroupid: number;
  remoteType: string;
  remoteName: string;
  videoTrackId: string;
  isAudioMute: boolean;
  isVideoMute: boolean;
  isActiveSpeaker: boolean;
  LayoutVideoState: number;
  MuteReason: number;
  extUserId: string;
  calluri: string;
  ExpectHeight: number;
  ExpectWidth: number;
  feccOri: number;
}

client.on('rotation-change', (e: IRotationInfo[]) => ())

interface IRotationInfoItem {
  height: number;
  width: number;
  participantId: number;
  // 数字0，1，2，3，其中：
  // 2顺时针旋转180度、3顺时针旋转270度、其他的数值可以不需要处理
  rotation: number;
  mediagroupid: number;
}

interface IRotationInfo {
  content: IRotationInfoItem[];
  people: IRotationInfoItem[];
  total: IRotationInfoItem[];
}

client.on('audio-status', (e: IMeetingAudioStatus) => {});

type IMeetingAudioStatus = {
  // muteAudio：本地麦克风静音状态
  // unmuteAudio：本地麦克风非静音状态
  status: 'muteAudio' | 'unmuteAudio';
}

client.on('video-status', (e: IMeetingVideoStatus) => {}): void;

type IMeetingVideoStatus = {
  // muteVideo：本地摄像头处于关闭状态
  // unmuteVideo：本地摄像头处于开启状态
  status: 'muteVideo' | 'unmuteVideo';
}

// IRoster接口类型见 roster 事件
client.on('content', (e: { data: IRoster }) => {}): void

client.on('content-pid', (e: string) => {}): void

client.on('meeting-control', (e: IMeetingControl) => {}): void;

interface IMeetingControl {
  // 会控是否强制静音此设备，true代表是强制静音，false代表接触强制静音
  // 强制静音后，建议将麦克风图标设置为举手发言状态，配合SDK API实现举手发言/取消举手/结束发言等逻辑；
  disableMute: boolean;
  // 会控控制麦克风状态，unmuteAudio代表取消麦克风静音，muteAudio代表麦克风静音；
  muteOperation: 'unmuteAudio' | 'muteAudio' | '';
  // 会控主会场/主画面设备calluri字段
  chairmanUri: string;
  // v2.1.1+支持，是否禁止收听远端声音，即控制当前参会终端禁止接收会中其他参会者声音；
  // 如何开启禁止收听功能：
  // 1、通过会控界面操作开启/关闭参会者接收声音开关
  // 2、通过小鱼Server API「禁止收听」操作会控禁止参会者收听远端音频
  isMuteSpeaker: IMuteSpeaker;
  // v2.1.1+支持，是否会控禁止分享Content内容；
  contentIsDisabled: boolean;
  // v2.1.2+支持，是否会控禁止云录制功能；
  recordIsDisabled: boolean;
  // v3.9.3+支持，是否开启了对话模式
  conferenceMode: ConferenceMode;
  // 轮询多画面控制Json字符串
  customizedLayout: string;
}

/**
 * 会控禁止收听远端参会者声音状态
 *
 * @value 'keep' - 保持上次的状态
 * @value 'on' - 禁止收听
 * @value 'off' - 取消禁止收听
 */
type IMuteSpeaker = 'keep' | 'on' | 'off';

/**
 * 会议模式
 *
 * @param DIALOG - 对话模式
 * @param NORMAL - 非对话模式
 */
enum ConferenceMode {
  DIALOG = 'dialog',
  NORMAL = 'normal'
}

client.on('sub-title', (e: ISubTitleContent) => {}): void;

interface ISubTitleContent {
  // 字体
  fontFamily?: string; 
  // 字体颜色
  fontRGB?: string; 
  // 是否滚动 1-滚 0-固定
  scroll?: string; 
  action?: string; // push、cancel
  location?: string; // 位置
  fontSize?: string; // 字体大小
  backgroundAlpha?: string; // 背景色透明度
  scrollSpeed?: string; // 滚动速度
  content: string; // 内容
  backgroundRGB?: string; // 背景色
}

client.on('participants-count', (e: IParticipantCount) => {}): void;

interface IParticipantCount {
  participantsNum: number;
}

client.on("speaker-info", (e: IScreenInfo) => {}): void;

interface ISpeakerInfo {
  // 设备类型Id
  endpointId: string;
  // 成员id
  pid: number;
}

client.on('onhold', (e: boolean) => {}): void

client.on('meeting-stats', (e: IInternels) => ())

/**
 * Internels 统计数据
 *
 * @property { number } bytesReceived 接收的字节总数
 * @property { number } bytesReceivedSecond 每秒接收字节数
 * @property { number } bytesSent 发送的字节总数
 * @property { number } bytesSentSecond 每秒发送字节数
 * @property { number } jitterSent 发送的抖动(ms)
 * @property { number } jitterReceived 接受的抖动(ms)
 * @property { number } roundTripTime 往返延时 (ms)
 * @property { number } fractionLostSent 视频发送的丢包率
 * @property { number } fractionLostReceived 视频接受的丢包率
 * @property { string } mimeType 视频类型
 * @property { number } timestamp 时间戳
 * @property { [prop: string]: IReceiver } receiver 所有接收视频的列表数据
 * @property { [prop: string]: ISender } sender 所有发送视频的列表数据
 * @property { [prop: string]: IReceiver } audioReceiver 所有接收音频的列表数据
 * @property { [prop: string]: ISender } audioSender 所有发送音频的列表数据
 * @property { number } audioSendLost 音频发送的丢包率，v2.1.2+支持
 * @property { number } audioRecvLost 音频接受的丢包率，v2.1.2+支持
 */
interface IInternels {
  bytesReceived: number;
  bytesReceivedSecond: number;
  bytesSent: number;
  bytesSentSecond: number;
  jitterSent: number;
  jitterReceived: number;
  audioSendJitter: number;
  roundTripTime: number;
  fractionLostSent: number;
  fractionLostReceived: number;
  mimeType: string;
  timestamp: number;
  receiver: {
    [prop: string]: IReceiver;
  };
  sender: {
    [prop: string]: ISender;
  };
  audioReceiver: {
    [prop: string]: IReceiver;
  };
  audioSender: {
    [prop: string]: ISender;
  };
  audioSendLost?: number;
  audioRecvLost?: number;
}

/**
 * 接收器 Receiver 统计数据
 *
 * @property { number } bytesReceived 接收总量
 * @property { number } bytesReceivedSecond 每秒接收数据
 * @property { number } frameHeight 解码帧的height
 * @property { number } frameWidth 解码帧的width
 * @property { number } framesDecoded frame编码量
 * @property { number } framesDecodedSecond 每秒frame编码量
 * @property { number } framesReceived frame接收量
 * @property { number } framesReceivedSecond 每秒frame接收量
 * @property { boolean } isContent 是否是分享content
 * @property { boolean } isSupport 忽略
 * @property { number } jitterBufferDelay 音频样本或视频帧从接收到退出抖动缓冲区所花费的时间总和，以秒为单位
 * @property { number } keyFramesDecoded 代表关键帧的总数
 * @property { number } nackCount 计算此接收器发送的否定确认（NACK）数据包的总数
 * @property { string } name 与会者昵称
 * @property { number } packetsReceived 此传输上收到的数据包总数
 * @property { number } packetsReceivedSecond 此传输上每秒收到的数据包数量
 * @property { number } packetsLost 此传输上丢失的数据包总数
 * @property { number } packetsLostSecond 此传输上每秒丢失的数据包数量
 * @property { number } pliCount 接收器发送的图片丢失指示（PLI）数据包的总数
 * @property { number } timestamp 时间戳
 * @property { string } type 与会者type
 * @property { number } expResolution 当前通道期望流分辨率
 * @property { string } status 状态
 * @property { number } framesPerSecond 此接收器解码的帧的 QP 值的总和
 * @property { string } ssrc 同步源 (ssrc) 标识符是每个 [RFC3550] 的无符号整数值，用于标识此 stats 对象正在描述的 RTP 数据包流；
 *                           对于出站和入站本地，ssrc 描述了分别由这些端点发送和接收的轨道的统计信息；
 *                           对于远程入站和远程出站，ssrc 描述了由远程端点接收和发送到远程端点的轨道的统计信息；
 * @property { number } jitter 视频接收抖动
 * @property { string } endpointId 参会者的callUri
 * @property { string } participantId participantId
 * @property { number } totalSamplesReceived  总的接受采样点
 * @property { number } insertedSamplesForDeceleration
 * @property { number } removedSamplesForAcceleration
 */
interface IReceiver {
  bytesReceived: number;
  bytesReceivedSecond: number;
  frameHeight: number;
  frameWidth: number;
  framesDecoded: number;
  framesDecodedSecond: number;
  framesReceived: number;
  framesReceivedSecond: number;
  isContent: boolean;
  isSupport: boolean;
  jitterBufferDelay: number;
  keyFramesDecoded: number;
  nackCount: number;
  name: string;
  packetsReceived: number;
  packetsReceivedSecond: number;
  packetsLost: number;
  packetsLostSecond: number;
  pliCount: number;
  timestamp: number;
  type: string;
  expResolution: number;
  status: string;
  framesPerSecond: number;
  framesDropped: number;
  ssrc: string;
  jitter: number;
  endpointId?: string;
  participantId?: number;
  mimeType?: string;
  audioLevel?: number; // 音频 audioLevel 值在[0, 1]之间，正常说话应该在0.1以上
  insertedSamplesForDeceleration?: number;
  insertedSamplesForDecelerationSecond?: number;
  totalSamplesReceived?: number;
  totalSamplesReceivedSecond?: number;
  removedSamplesForAcceleration?: number;
  removedSamplesForAccelerationSecond?: number;
  ExpectWidth?: number;
  ExpectHeight?: number;
}

/**
 * 发送器 Sender 统计数据
 *
 * @property { number } bytesSent 此RTCIceTransport上发送的有效负载字节总数
 * @property { number } bytesSentSecond 每秒发送有效负载字节数
 * @property { number } frameHeight 编码帧的高度
 * @property { number } frameWidth 编码帧的宽度
 * @property { number } framesEncoded 此RTP媒体流成功编码的帧总数
 * @property { number } framesEncodedSecond 每秒成功编码的帧数
 * @property { number } framesSent 此RTP流上发送的帧总数
 * @property { number } framesSentSecond 每秒发送的帧数
 * @property { number } hugeFramesSent 此RTP流发送的huge帧的总数
 * @property { string } status 忽略
 * @property { number } keyFramesEncoded 此RTP媒体流编码的关键帧总数
 * @property { number } packetsSent 此传输发送的数据包总数
 * @property { number } packetsSentSecond 此传输每秒发送的数据包数
 * @property { number } timestamp 时间戳
 * @property { string } type 发送器类型
 * @property { number } expBandwidth 期望带宽
 * @property { string } string 分辨率
 * @property { number } pliCount 计算此发送方收到的图片丢失指示 (PLI) 数据包的总数
 * @property { number } firCount 接收方已向发送方发送的完整帧内请求 (FIR) 数据包的数量
 * @property { number } nackCount 计算此发送方收到的否定确认 (NACK) 数据包的总数
 * @property { string } ssrc 标识此 stats 对象正在描述的 RTP 数据包流；
 *                           对于出站和入站本地，ssrc 描述了分别由这些端点发送和接收的轨道的统计信息；
 *                           对于远程入站和远程出站，ssrc 描述了由远程端点接收和发送到远程端点的轨道的统计信息；
 * @property { number } packetsLost 丢包总数
 * @property { boolean } isContent 是否是分享content
 * @property { boolean } jitter jitter
 * @property { boolean } roundTripTime 往返延时
 */
interface ISender {
  bytesSent: number;
  bytesSentSecond: number;
  frameHeight: number;
  frameWidth: number;
  framesEncoded: number;
  framesEncodedSecond: number;
  framesSent: number;
  framesSentSecond: number;
  hugeFramesSent: number;
  status: string;
  keyFramesEncoded: number;
  packetsSent: number;
  packetsSentSecond: number;
  timestamp: number;
  type: string;
  expBandwidth: number;
  resolution: string;
  pliCount: number;
  firCount: number;
  nackCount: number;
  ssrc: string;
  mimeType: string;
  audioLevel?: number;
  packetsLost: number;
  packetsLostSecond: number;
  isContent?: boolean;
  jitter?: number;
  roundTripTime?: number;
}

client.on("permission", (e: ICurrentPermission) => {}): void;

// v3.9.0+ 废弃此类型
// granted：已经授予权限
// denied：权限拒绝
// prompt：请求授权中
type TPermissionType = 'granted' | 'denied' | 'prompt' | '';

interface ICurrentPermission {
  microphone: TPermissionType;
  camera: TPermissionType;
}


// v3.9.0+ 类型更改
/**
 * 采集权限状态，v3.9.0+新增
 *
 * @param GRANTED granted - 已授权
 * @param DENIED denied - 已拒绝
 * @param PROMPT prompt - 询问中
 * @param UNKNOWN unknown - 未知
 * @param FAILED failed - 失败
 */
enum PermissionType {
  'GRANTED' = 'granted',
  'DENIED' = 'denied',
  'PROMPT' = 'prompt',
  'UNKNOWN' = 'unknown',
  'FAILED' = 'failed'
}

interface ICurrentPermission {
  microphone: PermissionType;
  camera: PermissionType;
}

client.on("currentDevice", (e: ICurrentDevice) => {}): void;

type TCurrentSelectedDevice = {
  deviceId: string;
  groupId: string;
  label: string;
};

type ICurrentDevice = {
  audioInput: TCurrentSelectedDevice;
  videoInput: TCurrentSelectedDevice;
  audioOutput: TCurrentSelectedDevice;
}

client.on('device', async (e: IDeviceManagerChangeValue) => {}): void;

interface IDeviceManagerChangeValue {
  // 设备列表发生变动时，Diff出来的新设备数据，一般情况下直接切换使用最新设备数据即可
  nextDevice: {
    audioInput: TCurrentSelectedDevice;
    videoInput: TCurrentSelectedDevice;
    audioOutput: TCurrentSelectedDevice;
  };
  // 所有输出/输出设备列表数据
  detail: {
    audioInputList: TDevice[];
    audioOutputList: TDevice[];
    videoInList: TDevice[];
  };
};

type TDevice = {
  deviceId: string;
  kind: string;
  type: string;
  direction: 'audioinput' | 'output' | 'input';
  label: string;
  groupId: string;
};

export type TCurrentSelectedDevice = {
  deviceId: string;
  groupId: string;
  label: string;
}

client.on('bulkRoster', async (e: IBulkRoster) => {}): void;

interface IBulkRoster {
  // 数据类型，0表示全量数据，1表示增量数据
  bulkRosterType: 0 | 1;
  // 新增的roster信息
  addRosterInfo: IRoster[];
  // 变化的roster信息
  changeRosterInfo: IRoster[];
  // 被删除的roster信息
  deleteRosterInfo: { participantId: string }[];
}

client.on('conference-info', (e: IConferenceInfo) => {}): void;

export interface IConferenceInfo {
  // 最终进入的真实会议号
  callNumber: string;
  // 呼叫号码真实url
  callUrl?: string;
  // 号码id
  deviceId?: string;
  // 号码类型
  deviceType?: string;
  // 云会议号名称
  displayName?: string;
  // 呼叫的号码
  number?: string;
  // 会议号类型
  numberType?: string;
  // 会议配置
  confAuxProperties?: IConfAuxProperties;
  // 头像
  avatar?: string;
  // 需通过setFeatureConfig启用查询小鱼会议邀请链接信息，默认不启用
  // v3.8.0+ 会议分享信息，包含会议邀请链接、电话，WebRTC、终端等端的入会方式； 
  inviteInfo?: InviteInfo;
  // v3.8.0+ 当前会议ID
  meetingId?: string;
}


/**
 * 会议分享信息
 *
 * @property { string } displayName - 会议室名称
 * @property { boolean } inEnterprise - 所属会议号是否在企业中
 * @property { string } inviteAppUrl - 微信邀请链接
 * @property { string } inviteUrl - 云会议室邀请链接
 * @property { string } invokSchema - 小鱼客户端Scheme获取地址
 * @property { string } linkNumber - 电话入会号码
 * @property { string } mobileWebrtcVisibleSetting - 移动端是否显示WebRTC入会
 * @property { string } number - 会议号
 * @property { string } password - 入会密码
 * @property { string } pstnNumber - 电话呼叫号码
 * @property { string } shareUrl - 邀请链接详情页地址
 * @property { string } userAvatar - 管理员头像
 * @property { string } userName - 管理员名称
 * @property { string } userProfileId - 用户ID
 * @property { string } voiceNumber - 电话呼叫时的会议号
 * @property { string } webrtcSetting - PC端是否显示WebRTC入会
 * @property { string } webrtcUrl - WebRTC入会地址
 *
 */
interface InviteInfo {
  displayName: string;
  inEnterprise: boolean;
  inviteAppUrl: string;
  inviteUrl: string;
  invokSchema: string;
  linkNumber: string;
  mobileWebrtcVisibleSetting: boolean;
  number: string;
  password: string;
  pstnNumber: string;
  shareUrl: string;
  userAvatar: string;
  userName: string;
  userProfileId: string;
  voiceNumber: string;
  webrtcSetting: boolean;
  webrtcUrl: string;
}

client.on('page-info', (e: IPageInfo) => {}): void;

interface IPageInfo {
  // 每一页显示的画面数量
  pageSize: number;
  // 当前是第几页，默认是0开始
  currentPage: number;
  // 总页数
  totalPage: number;
}

client.on('in-out-reminder', (e: IReminder[]) => {}): void;

interface IReminder {
  // 用户名称
  displayName: string;
  // 出入会状态，in：加入会议，out：退出会议
  action: 'in' | 'out';
  // 用户id
  userId?: string;
}

client.on('conf-change-info', (e: IConfInfo) => {}): void;

interface IConfInfo {
  // 当前会议参会者总人数，不包含共享内容设备数量
  participantCount: number;
  // 当前会议参会者总人数，包含共享内容、指挥调度客户端等设备数量
  totalEpCount: number;
  // 当前会议主会场/主画面设备的callUrl，没有为''
  chairManUrl: string;
  // 当前会议共享内容设别的callUrl，没有为''
  contentUri: string;
  // 当前会议语音激励者的callUrl，没有为''
  actSpkUri: string;
  // 多分组通人数信息，默认上报0和1分组，分别代表People通道和Content通道
  mediaGroupInfo: IMediaGroupInfo[];
}

interface IMediaGroupInfo {
  // 通道参会者数量
  endpointCount: number;
  // 通道
  mediagroupid: number;
}

client.on('force-full-screen', (e: string) => {}): void;

client.on('translation-content', (data: ITranslationContent) => {});

/**
 * 通话字幕内容
 *
 * @property { number } pid 当前说话的终端
 * @property { string } src 原文
 * @property { string } target 译文
 * @property { number } seTime 发送时间
 * @property { number } startTime 开始时间
 * @property { number } endTime 结束时间
 * @property { boolean } isEnd 一句话是否结束
 * @property { boolean } isActive 活跃标志,收三路，同时只有一路active
 * @property { string } url 终端calluri
 * @property { string } dn 显示名称
 * @property { string } meetingId 会议号
 * @property { string } srcLang 原语言，zh表示中文，en表示英文
 * @property { string } targetLang 译文语言，zh表示中文，en表示英文
 */
interface ITranslationContent {
  pid: number;
  src: string;
  target: string;
  seTime: number;
  startTime: number;
  endTime: number;
  isEnd: boolean;
  isActive: boolean;
  url: string;
  dn: string;
  meetingId: string;
  srcLang: string;
  targetLang: string;
}

client.on('record-permission', (e: IRecordPermission) => {});

/**
 * 录制权限
 *
 * @property { boolean } authorize 权限
 * @property { string } recordingUrl 云会议室URI
 * @property { string? } developerMessage 云会议室的所属用户名称
 * @property { number? } errorCode 错误码
 * @property { string? } userMessage 错误信息
 */
interface IRecordPermission {
  authorize: boolean;
  recordingUrl: string;
  developerMessage?: string;
  errorCode?: number;
  userMessage?: string;
}

client.on('record-status-notification', (e: IRecordStatusNotification) => {});

/**
 * 远端(或会控)录制状态通知；如果存在录制，则本地不可以进行录制
 *
 * @property { boolean } isStart true:存在录制；false:不存在录制
 * @property { string } uri 录制的displayName，即callUri的名称，当是" "时，取会议室名称
 * @property { string } callUri 谁开始/停止的录制
 * @property { string } callerUri
 * @property { string } status RECORDING_STATE_PAUSED(录制暂停)、RECORDING_STATE_ACTING(录制恢复)
 * @property { boolean } isLocal 是否是local开启的录制
 * @property { IRecordInfo } recordInfo - 录制文件相关信息
 */
interface IRecordStatusNotification {
  isStart: Boolean;
  uri: string; 
  callUri: string; 
  callerUri: string;
  status: string; 
  isLocal: boolean;
  recordInfo: IRecordInfo;
}


/**
 * 录制相关信息
 * 3.9.6+增加
 *
 * @property { string } recordSessionId - sessionId
 */
interface IRecordInfo {
  recordSessionId: string;
}

client.on('recording-state-changed', (e: IRecordingStateChanged) => {});

/**
 * 本地录制状态上报
 *
 * @property { string } reason 结果Reason，成功STATE:200
 * @property { RecordingState } state 结果状态：
 * @property { boolean } isRecorded 本地录制相关，暂时不用
 * @property { string } controlUri 
 * @property { string } reasonText 提示语
 * @property { IRecordInfo } recordInfo - 录制文件相关信息
 */
interface IRecordingStateChanged {
  reason: string;
  state: RecordingState;
  isRecorded: boolean;
  controlUri: string;
  reasonText: string;
  recordInfo: IRecordInfo;
}


/**
 * 录制相关信息
 * 3.9.6+增加
 *
 * @property { string } recordSessionId - sessionId
 */
interface IRecordInfo {
  recordSessionId: string;
}

/**
 * 录制状态
 *
 * @param  RECORD_STATE_IDLE  停止成功
 * @param  RECORD_STATE_STARTING 开启录制
 * @param  RECORD_STATE_STARTED 开启成功
 * @param  RECORD_STATE_STOPING 停止录制
 */
enum RecordingState {
    RECORD_STATE_IDLE = "RECORD_STATE_IDLE",
    RECORD_STATE_STARTING = "RECORD_STATE_STARTING",
    RECORD_STATE_STARTED = "RECORD_STATE_STARTED",
    RECORD_STATE_STOPING = "RECORD_STATE_STOPING"
}

client.on('multi-group-info', (e: IMultiGroupInfo) => {});

/**
* @param { string } endpointId 拥有多分组的参会者/终端id
* @param { string[] | number[] } mediagrps 多路分组通道信息，启动通道时需要传递此值
*/
interface IMultiGroupInfo { 
  endpointId: string, 
  mediagrps: string[] | number[]
}

client.on('custom-message-recv', (e: IReceiveCustomMessage) => {});

/**
 * 接收到自定义消息
 *
 * @property { string } type - 消息Type
 * @property { number } fromPid - 消息的发送方pid
 * @property { number } toPid - 消息的接收方pid，0表示广播消息、非0表示单点消息；
 * @property { string } data - 消息内容，可以被JSON序列化的字符串；
 */
interface IReceiveCustomMessage {
  type: string;
  fromPid: number;
  toPid: number;
  data: string;
}

client.on('user-info', (e: IExportUserInfo) => {});

/**
 * 个人云会议室信息
 * 默认只保存了部分信息
 *
 * @property { string? } meetingControlPassword 会控密码
 * @property { string? } meetingNumber 个人云会议室号码
 * @property { string? } password 入会密码
 */
interface ICloudRoomConfig {
  meetingControlPassword: string;
  meetingNumber: string;
  password: string;
}


/**
 * SDK登录用户信息
 *
 * @property { string? } callUri 用户类型ID
 * @property { string } securityKey 安全码
 * @property { string } access_token Token
 * @property { string } refresh_token 刷新Token
 * @property { number } id 用户ID
 * @property { string } displayName 登录用户名
 * @property { string } cellPhone 呼叫号码
 * @property { string } extUserId 第三方用户ID
 */
interface ILoginInfo {
  callUri?: string;
  securityKey: string;
  access_token: string;
  refresh_token?: string;
  id: number;
  displayName?: string;
  cellPhone?: string;
  extUserId?: string;
}

/**
 * 用户和对应个人云会议室信息数据
 */
interface IExportUserInfo extends ILoginInfo {
  cloudRoomInfo: ICloudRoomConfig || null;
}

client.on('speakers-info', (e: SpeakersInfo) => {});

/**
 * 讲话者信息
 *
 * @property { string } alias - 别名id
 * @property { string } name - 讲话者名称
 * @property { string } pid - pid
 *
 */
interface SpeakersInfoObj {
  alias: string;
  name: string;
  pid: number;
}

/**
 * 实时讲话人消息体
 *
 * @property { speakersInfoObj[] } speakersInfo - 讲话者信息
 */
interface SpeakersInfo {
  speakersInfo: SpeakersInfoObj[];
}

client.on('meeting-control-video', (e: IMCVideoEvent) => {});

/**
 * 会控开启/关闭摄像头消息、Toast提示消息
 */
type IMCVideoEvent = controlVideoQuery | unMuteVideoQueryToast;

/**
 * 主持端得到远端开启摄像头结果的提示消息体
 *
 * @property { string } message - 消息体，需要解析，详细内容如下：
 * no.camera.permission: 终端未授权App摄像头权限
 * reject.unmute.video: 参会人拒绝开启摄像头
 * voice.mode: 终端在语音模式
 * driving.mode: 终端在驾驶模式
 * unmute.video.timeout: 超时
 * @property { string } di - 终端的deviceUri
 * @property { string } dn - 终端的名称
 */
interface unMuteVideoQueryToastValue extends videoQueryBase {
  message: string;
  di: string;
  dn: string;
}

/**
 * 会控推送开启/关闭摄像头消息体
 *
 * @property { string } key - 消息key，值为：'unMuteVideoQuery' | 'muteVideoQuery'
 * @property { videoQueryBase } value - 消息详细内容
 *
 */
interface controlVideoQuery {
  key: queryType;
  value: videoQueryBase;
}

/**
 * 会控开关摄像头事件基础消息体
 *
 * @property { string } confUri - 会议号
 * @property { string } encryption - 加密信息
 * @property { boolean } force - 是否强制开启摄像头
 * @property { string } meetingId - 会议ID
 * @property { string } requestId - 事件ID
 * @property { string } uri - 事件接收侧用户ID
 *
 */
interface videoQueryBase {
  confUri: string;
  encryption: string;
  force: boolean;
  meetingId: string;
  requestId: string;
  uri: string;
}

client.on('networkLevel', (e: NetworkQualityLevel) => {});

/**
 * 网络质量信号等级
 *
 * @param Bad 1 - 非常差
 * @param Poor 2 - 差
 * @param Good 3 - 一般
 * @param Excellent 4 - 很好
 */
enum NetworkQualityLevel {
  Bad = 1,
  Poor,
  Good,
  Excellent
}

client.on('networkParamet', (e: INetworkParameter) => {});


/**
 * 远端网络质量信号等级
 *
 * @property { string } fromCallUri - 远端的callUri
 * @property { number } fromPid - 远端的pid
 * @property { NetworkQualityLevel } - networkLevel 网络质量信号等级
 * @property { string } toCallUri - local callUri
 *
 */
export interface INetworkParameter {
  fromCallUri: string;
  fromPid: number;
  networkLevel: NetworkQualityLevel;
  toCallUri: string;
}


/**
 * 网络质量信号等级
 *
 * @param Bad 1 - 非常差
 * @param Poor 2 - 差
 * @param Good 3 - 一般
 * @param Excellent 4 - 很好
 */
enum NetworkQualityLevel {
  Bad = 1,
  Poor,
  Good,
  Excellent
}

client.on('focus-view', (e: IRoster | null) => {});


interface IRoster {
  // 设备类型
  deviceType: string;
  // 设备Id
  endpointId: string;
  // 名称
  displayName: string;
  // people or content标示，0代表people，1代表Content内容
  mediagroupid: number;
  // 成员pid值
  participantId: number;
  // 当前设备麦克风的状态
  audioTxMute: boolean;
  // 当前设备摄像头状态
  videoTxMute: boolean;
  // 忽略
  audioRxMute: boolean;
  // 忽略
  videoRxMute: boolean;
  // 忽略
  videoMuteReason: number;
  // 是否是主会场
  isFocusScreen: boolean;
  // 是否是焦点画面 v3.9.4+
  isFocusScreen: boolean;
  // 忽略
  isLastAdd: boolean;
  // 是否是呼叫等待状态
  onHold: boolean;
  // 是否正在轮询显示
  isPolling: boolean;
  // 是否是content内容
  isContent: boolean;
  // 是否是Local设备
  isLocal: boolean;
  // 唯一id值
  id: string;
  // 是否是activeSpeaker语音激励
  isActiveSpeaker?: boolean;
}

client.on('template-mode', (templateMode: IMode) => {});


/**
 * 布局模式
 * 
 * @param SPEAKER - 演讲者模式，即 1大N小 画面模式
 * @param GALLERY - 画廊模式，即 宫格布局
 * 
 * content布局
 * @param MULTI_PIC_CONTENT_HIGH_PRIORITY - 缩略视图, Content是大窗口
 * @param MULTI_PIC_ACTIVE_HIGH_PRIORITY - 缩略共享, ActiveSpeaker是大窗口
 * @param TWO_PIC_PIP - 共享视图, 画中画模式(picture in picture)
 * @param CONTENT_ONLY - 共享全视图, 只显示Content
 * @param TWO_PIC_SYMMETRIC - 共享+演讲, 对称显示content和speaker(side by side)
 */
type IMode = "SPEAKER" | "GALLERY" | "MULTI_PIC_CONTENT_HIGH_PRIORITY" | "MULTI_PIC_ACTIVE_HIGH_PRIORITY" | "TWO_PIC_PIP" | "CONTENT_ONLY" | "TWO_PIC_SYMMETRIC"

client.on('layout-state', (state: LayoutState) => {});

/**
 * Layout状态，当前仅支持上报轮询多画面状态
 *
 * @property { boolean } isPolling - 是否增在轮询中，true代表正在轮询中，false代表结束/暂停轮询状态
 */
interface LayoutState {
  isPolling: boolean;
}

client.on('notification', (e: Notification) => {});


/**
 * 联席主持人/改名权限 等消息
 *
 * @property { number } subType - 消息类型
 * @property { NotificationContent } content - 消息详细内容
 * @property { string } requestId - 消息ID
 */
export interface Notification {
  subType: number;
  content: NotificationContent;
  requestId: string;
}


/**
 * 信令上报的消息
 *
 * @property { CoChair } coChair - 是否是联席主持人
 * @property { EnableRename } enableRename - 是否有改名权限
 * @property { string } meetingId - 会议ID
 */
export interface NotificationContent {
  coChair?: CoChair;
  enableRename?: EnableRename;
  meetingId?: string;
}

/**
 * 是否有改名权限
 *
 * @param ON - 是
 * @param OFF - 否
 */
export enum EnableRename {
  ON = 'on',
  OFF = 'off'
}