import { ILogger, ConversationType, RTCJoinType, LogLevel, LogL, IPushConfig as IPushConfig$1, IReceivedMessage, EventEmitter, RTCPluginContext, IRuntime, BasicLogger, IRTCJoinedInfo, IPluginGenerator } from '@rongcloud/engine';
import { RCRTCClient, IMicphoneAudioProfile, RCTrack, RCRTCCode, IRCRTCStateReport, RCRTCPingResult, RCLocalTrack, ICameraVideoProfile } from '@rongcloud/plugin-rtc';
export { IRCRTCStateReport } from '@rongcloud/plugin-rtc';

/**
 * 错误码，与移动端对齐
 * @description
 * 1. `51000 - 51999` 为 Android 专用段
 * 2. `52000 - 52999` 为 iOS 专用段
 * 3. `53000 - 53199` 为 Web RTC 专用段
 * 4. `53200 - 53499` 为 Web CallLib 专用段
 * *  `53200 - 53299` 为 Web CallEngine 专用端
 * *  `53300 - 53499` 为 Web Call 专用端
 * 5. `53500 - 53999` 为 Web 保留段
 */
declare enum RCCallErrorCode {
    /**
     * 成功
     */
    SUCCESS = 10000,
    /**
     * 存在未结束的状态机
     */
    STATE_MACHINE_EXIT = 53200,
    /**
     * 发送 IM 消息失败
     */
    SEND_MSG_ERROR = 53201,
    /**
     * 被对方加入黑名单
     */
    REJECTED_BY_BLACKLIST = 53202,
    /**
     * 当前用户不再群组中
     */
    NOT_IN_GROUP = 53203,
    /**
     * Call 相关
     */
    /**
     * 获得本地音频流失败
     */
    GET_LOCAL_AUDIO_TRACK_ERROR = 53301,
    /**
     * 获得本地视频流失败
     */
    GET_LOCAL_VIDEO_TRACK_ERROR = 53302,
    /**
     * 获得本地音视频流失败
     */
    GET_LOCAL_AUDIO_AND_VIDEO_TRACK_ERROR = 53303,
    /**
     * 加入房间失败
     */
    JOIN_ROOM_ERROR = 53304,
    /**
     * 发布音频失败
     */
    AUDIO_PUBLISH_ERROR = 53305,
    /**
     * 发布视频失败
     */
    VIDEO_PUBLISH_ERROR = 53306,
    /**
     * 发布音视频失败
     */
    AUDIO_AND_VIDEO_PUBLISH_ERROR = 53307,
    /**
     * 查询房间用户信息失败
     */
    QUERY_JOINED_USER_INFO_ERROR = 53308,
    /**
     * 禁用启用视频时，房间内缺少视频流
     */
    MISSING_VIDEO_TRACK_ERROR = 53309,
    /**
     * 取消发布视频失败
     */
    UNPUBLISH_VIDEO_ERROR = 53310,
    /**
     * 会话不是群组
     */
    CONVERSATION_NOT_GROUP_ERROR = 53311,
    /**
    * 不在room中禁用音视频
    */
    NOT_IN_ROOM_ERROR = 53312,
    /**
     * 参数错误
     */
    PARAM_ERROR = 53313,
    /**
     * 缺少本地音频流
     */
    MISSING_AUDIO_TRACK_ERROR = 53314,
    /**
     * 通话已结束
     */
    SESSION_ENDED = 53315
}

/**
 * 挂断原因
 * @description
 * 根据原有 HangupReason 设计，己方原因与对方原因有相差 10 的差距.
 * 现有本地原因取值范围: 1 ~ 10, 远端原因取值范围: 11 ~ 20.
 * 为便于 HangupReason 扩展，保留 100 以内的取值.
 * 需要再次扩展时，己方原因使用: 21 ~ 30, 对应对方原因使用: 31 ~ 40,
 * 以此类推，
 * 己方原因使用: 41 ~ 50, 对方原因使用: 51 ~ 60,
 * 己方原因使用: 61 ~ 70, 对方原因使用: 71 ~ 80,
 * 己方原因使用: 71 ~ 90, 对方原因使用: 91 ~ 100.
 *
 * 各平台独有字段范围
 * Android 201 ~ 299
 * iOS     301 ~ 399
 * Web     401 ~ 499
 * 详细文档：https://gitbook.rongcloud.net/rtc-docs/#/rtc-client/ios/analysis/calllib/HangupReason
 */
declare enum RCCallEndReason {
    /**
     * 己方取消已发出的通话请求
     */
    CANCEL = 1,
    /**
     * 己方拒绝收到的通话请求
     */
    REJECT = 2,
    /**
     * 己方挂断
     */
    HANGUP = 3,
    /**
     * 己方忙碌
     */
    BUSY_LINE = 4,
    /**
     * 己方未接听
     */
    NO_RESPONSE = 5,
    /**
     * 己方不支持当前音视频引擎
     */
    ENGINE_UNSUPPORTED = 6,
    /**
     * 己方网络错误
     */
    NETWORK_ERROR = 7,
    /**
     * 己方摄像头资源获取失败，可能是权限原因
     */
    GET_MEDIA_RESOURCES_ERROR = 8,
    /**
     * 己方资源发布失败
     */
    PUBLISH_ERROR = 9,
    /**
     * 己方订阅资源失败
     */
    SUBSCRIBE_ERROR = 10,
    /**
     * 对方取消发出的通话请求
     */
    REMOTE_CANCEL = 11,
    /**
     * 对方拒绝收到的通话请求
     */
    REMOTE_REJECT = 12,
    /**
     * 通话过程中对方挂断
     */
    REMOTE_HANGUP = 13,
    /**
     * 对方忙碌
     */
    REMOTE_BUSY_LINE = 14,
    /**
     * 对方未接听
     */
    REMOTE_NO_RESPONSE = 15,
    /**
     * 对方引擎不支持
     */
    REMOTE_ENGINE_UNSUPPORTED = 16,
    /**
     * 对方网络错误
     */
    REMOTE_NETWORK_ERROR = 17,
    /**
     * 对方摄像头资源获取失败，可能是权限原因
     */
    REMOTE_GET_MEDIA_RESOURCE_ERROR = 18,
    /**
     * 远端资源发布失败
     */
    REMOTE_PUBLISH_ERROR = 19,
    /**
     * 远端订阅资源失败
     */
    REMOTE_SUBSCRIBE_ERROR = 20,
    /**
     * 己方其他端已加入新通话
     */
    OTHER_CLIENT_JOINED_CALL = 21,
    /**
     * 己方其他端已在通话中
     */
    OTHER_CLIENT_IN_CALL = 22,
    /**
     * 己方被禁止通话
     */
    KICKED_BY_SERVER = 23,
    /**
     * 己方接听系统通话（移动端特有）
    */
    ACCEPT_SYSTEM_CALL = 24,
    /**
     * 远端其他端已加入新通话
     */
    REMOTE_OTHER_CLIENT_JOINED_CALL = 31,
    /**
     * 远端其他端已在通话中
     */
    REMOTE_OTHER_CLIENT_IN_CALL = 32,
    /**
     * 远端被禁止通话
     */
    REMOTE_KICKED_BY_SERVER = 33,
    /**
     * 远端接听系统通话（移动端特有）
    */
    REMOTE_ACCEPT_SYSTEM_CALL = 34,
    /**
     * 其他端接听
     */
    ACCEPT_BY_OTHER_CLIENT = 101,
    /**
     * 其他端挂断
     */
    HANGUP_BY_OTHER_CLIENT = 102,
    /**
     * 己方被对方加入黑名单
     */
    ADDED_TO_BLACKLIST = 103,
    /**
     * 音视频服务未开通
     */
    SERVICE_NOT_OPENED = 104
}

/**
 * 通话媒体类型
 */
declare enum RCCallMediaType {
    /**
     * 音频通话
     */
    AUDIO = 1,
    /**
     * 视频通话
     */
    AUDIO_VIDEO = 2
}

declare enum RCCallSessionState {
    /**
     * 等待建立连接
     */
    WAITING = 0,
    /**
     * 会话维持中
     */
    KEEPING = 1,
    /**
     * 会话已结束
     */
    END = 2
}

declare enum RCCallUserState {
    /**
     * 用户不存在于通话中
     */
    NONE = 0,
    /**
     * 等待接听
     */
    WAITING = 1,
    /**
     * 通话中
     */
    KEEPING = 2
}

/**
 * 产生session的场景
 */
declare enum ProduceTypes {
    /**
     * 主叫
     */
    CALLER = 1,
    /**
     * 被叫
     */
    CALLEE = 2
}

declare class RCCallSession {
    /**
     * 状态机实例
     */
    private _stateMachine;
    /**
     * rtc实例
     */
    private readonly _rtcClient;
    private readonly _logger;
    /**
     * session的其它选项
     */
    private _options;
    /**
     * RTC房间实例
     */
    private _room;
    /**
     * 用户传进来的 对session的监听 (要在RCCallClient的_onInvite里判断，要求执行完onSession必须注册session的监听，所以这里是public)
     */
    _listener: ISessionListener | null;
    /**
     * RTC订阅、发布重试的次数
     */
    private readonly _RETRYCOUNT;
    /**
     * 加入房间定时器
     */
    private joinRoomTimer;
    constructor(
    /**
     * 状态机实例
     */
    _stateMachine: RCCallStateMachine, 
    /**
     * rtc实例
     */
    _rtcClient: RCRTCClient, _logger: ILogger, 
    /**
     * session的其它选项
     */
    _options?: IRCCallSessionOptions);
    /**
     *  加入房间
     */
    private _joinRoom;
    /**
     * (初始化房间的时候) 订阅远程的流，把远程的流抛给用户
     */
    private _subscribeInRoomRemoteTrack;
    /**
     * 可以重试的订阅
     * @param params.tracks tracks
     * @param params.isAllowSubscribeRetry 是否允许重试
     * @param params.count 允许重试的次数
     */
    private _subscribeRetry;
    /**
     * 发布本地资源的逻辑
     *
     */
    private _publish;
    /**
     * 可以重试的发布
     * @param params.tracks tracks
     * @param params.isAllowPublishRetry 是否允许重试
     * @param params.count 允许重试的次数
     */
    private _publishRetry;
    /**
     * 退出房间
     */
    private _leaveRoom;
    /**
     * 出现异常后要处理的逻辑,
     * @param endReason 原因
     */
    private _exceptionClose;
    /**
     * 用户调用的，注册session上的监听
     */
    registerSessionListener(listener: ISessionListener): void;
    /**
     * 调RTC API 获得本地流
     */
    private _getLocalTrackCore;
    private _getLocalTrack;
    /**
     * 通话中更换音频设备
     */
    changeAudioDevice(audioConstraints?: IMicphoneAudioProfile): Promise<{
        code: RCCallErrorCode;
    }>;
    /**
     * 群呼叫中继续邀请
     * @param userIds 被邀请用户 ID 列表
     * @param options 透传参数配置及移动端推送配置
     */
    invite(userIds: string[], options?: IInviteOptions): Promise<{
        code: RCCallErrorCode;
    }>;
    /**
     * 同意接听
     */
    accept(constraints?: IMediaStreamConstraints): Promise<{
        code: RCCallErrorCode;
    }>;
    /**
     * 挂断
     */
    hungup(): Promise<{
        code: RCCallErrorCode;
    }>;
    /**
     * 通话媒体变更
     *  @param mediaType RCCallMediaType.AUDIO 改为音频通话 | RCCallMediaType.AUDIO_VIDEO 改为音视频通话
     */
    _changeMediaType(mediaType: RCCallMediaType): Promise<{
        code: RCCallErrorCode;
    }>;
    /**
     * 获得本地视频
     */
    private _getLocalVideoTracks;
    /**
     * 获得本地音频
     */
    private _getLocalAudioTracks;
    /**
     * 把通话的MediaType升级到音视频
     */
    private _setMediaTypeToAudioAndVideo;
    /**
     * 把通话的MediaType降级到音频
     * @param isSendMesssage 是否需要发消息, 默认发消息
     */
    private _setMediaTypeToAudio;
    /**
     * 通话降级，目前需求只做通话降级，音视频可以降级为音频，音频不能升到音视频, 发消息成功才算降级成功
     *
     */
    descendAbility(): Promise<{
        code: RCCallErrorCode;
    }>;
    /**
     * 禁用视频track
     */
    disableVideoTrack(): Promise<{
        code: RCCallErrorCode;
    }>;
    /**
     * 启用视频track
     */
    enableVideoTrack(): Promise<{
        code: RCCallErrorCode;
    }>;
    /**
     * 禁用音频track
     */
    disableAudioTrack(): Promise<{
        code: RCCallErrorCode;
    }>;
    /**
     * 启用音频track
     */
    enableAudioTrack(): Promise<{
        code: RCCallErrorCode;
    }>;
    /**
     * 销毁本地流
     */
    private _destroyTracks;
    /**
     * 向外抛出本地流
     */
    private _notifyTrackReady;
    /**
     * 房间上注册事件
     */
    private _registerRoomEventListener;
    /**
     * 注册房间质量数据监听器
     */
    private _registerReportListener;
    /**
     *  通话唯一标识
     */
    getSessionId(): string;
    /**
     *  获取房间当前会话 Id，当房间内已无成员时房间会回收，重新加入时 sessionId 将更新，(用户录制资源用的)
     */
    getRTCSessionId(): string | null;
    /**
     *  目标 ID，单呼对方人员 Id, 群呼群组 Id
     */
    getTargetId(): string;
    /**
     *  获取会话类型
     */
    getConversationType(): ConversationType;
    /**
     *  组织 ID
     */
    getChannelId(): string;
    /**
     * 房间人员列表，不包含本端信息
     */
    getRemoteUsers(): IUserData[];
    /**
   * 房间人员列表，不包含本端信息
   */
    getUsers(): IUserData[];
    /**
     * 获取人员状态
     */
    getUserState(userId: string): RCCallUserState;
    /**
     * 获取session状态
     */
    getState(): RCCallSessionState;
    /**
     * 获得会话发起者id
     */
    getCallerId(): string;
    /**
     * 获得mediaType
     */
    getMediaType(): RCCallMediaType;
}

interface ISender {
    userId: string;
    /**
    * 用户名
    */
    name?: string;
    /**
    * 用户头像地址
    */
    portraitUri?: string;
    /**
    * user info 中附加信息
    */
    extra?: string;
}
interface IMuteUser extends ISender {
    /**
     * 是否禁用
     */
    muted: boolean;
    /**
     * track类型
     */
    kind: string;
    /**
     * trackId
     */
    trackId: string;
}
/**
 * CallLib 初始化参数
 */
interface IRCCallInitOptions {
    /**
     * RTC实例
     */
    rtcClient: RCRTCClient;
    /**
     * 收到邀请后，产生新的session
     */
    onSession: (session: RCCallSession, extra?: string) => void;
    /**
     * session已关闭
     */
    onSessionClose: (session: RCCallSession, summary?: IEndSummary) => void;
    /**
     * 离线期间收到的呼叫记录
     * @param record
     * @returns
     */
    onOfflineRecord?: (record: IOfflineRecord) => void;
    /**
     * 是否允许接听新呼叫，当前正在通话，如果收到新的邀请，是直接挂断，还是允许选择, 默认值false,直接挂断新的session
     *
     * 暂不对外暴露
     */
    /**
    * 是否允许订阅重试， 默认为false
    */
    isAllowSubscribeRetry?: boolean;
    /**
     * 是否允许发布重试， 默认为false
     */
    isAllowPublishRetry?: boolean;
    /**
     * 禁用视频时关摄像头, 默认false
     */
    isOffCameraWhenVideoDisable?: boolean;
    /**
     * RTC 房间加入类型
     */
    joinType?: RTCJoinType;
    /**
     * 允许降级获得流，获得音视频不成功 ，降级获得音频
     */
    isAllowDemotionGetStream?: boolean;
    /**
     * 该参数已废弃，请使用 `logOutputLevel` 替代
     * @deprecated - version 5.2.2
     */
    logLevel?: LogLevel;
    /**
     * 日志输出等级
     * @since version 5.2.2
     */
    logOutputLevel?: LogL.DEBUG | LogL.INFO | LogL.WARN | LogL.ERROR;
    /**
     * 该参数已废弃
     * @deprecated - version 5.2.0
     */
    logStdout?: (logLevel: LogLevel, content: string) => void;
    /**
     * 语言设置 (推送), 不传默认为中文
     */
    lang?: RCCallLanguage;
}
/**
 * 呼叫、挂断推送信息
 */
interface IPushConfig extends Partial<IPushConfig$1> {
}
/**
 * session上的监听
 */
interface ISessionListener {
    /**
     * 当对方已响铃
     */
    onRinging(sender: ISender, session: RCCallSession): void;
    /**
     * 当对方已同意
     */
    onAccept(sender: ISender, session: RCCallSession): void;
    /**
     * 当对方已挂断
     */
    onHungup(sender: ISender, reason: RCCallEndReason, session: RCCallSession): void;
    /**
     * 群组通话，人员改变
     */
    onMemberModify(sender: ISender, invitedUsers: IInvitedUsers[], session: RCCallSession): void;
    /**
     * 通话降级
     */
    onMediaModify(sender: ISender, mediaType: RCCallMediaType, session: RCCallSession): void;
    /**
     * 当接到流
     */
    onTrackReady(track: RCTrack, session?: RCCallSession): void;
    /**
     * 关闭 或 开启 音频
     */
    onAudioMuteChange(muteUser: IMuteUser, session: RCCallSession): void;
    /**
     * 关闭 或 开启 视频
     */
    onVideoMuteChange(muteUser: IMuteUser, session: RCCallSession): void;
    /**
    * 资源订阅失败
    */
    onTrackSubscribeFail?(code: RCRTCCode, session: RCCallSession): void;
    /**
    * 资源发布失败
    */
    onTrackPublishFail?(code: RCRTCCode, session: RCCallSession): void;
    /**
     * 用于接收RTC状态数据报告
     */
    onRTCStateReport?(report: IRCRTCStateReport, session: RCCallSession): void;
    /**
     * RTC 每次 Ping 结果
     */
    onPing?(result: RCRTCPingResult, session: RCCallSession): void;
    /**
     * ~ICE 连接状态变更通知~
     * @since version 5.1.5
     */
    onICEConnectionStateChange?(state: RTCIceConnectionState, session: RCCallSession): void;
}
/**
 * 创建session的options
 */
interface IRCCallSessionOptions {
    /**
     * 本地资源,用户主动发起会话的时候，会先获得本地资源
     */
    localTracks?: RCLocalTrack[];
    /**
     * 是否允许订阅重试， 默认为false
     */
    isAllowSubscribeRetry?: boolean;
    /**
     * 是否允许发布重试， 默认为false
     */
    isAllowPublishRetry?: boolean;
    /**
     * 禁用视频时关摄像头, 默认false
     */
    isOffCameraWhenVideoDisable?: boolean;
    /**
     * RTC 房间加入类型
     */
    joinType?: RTCJoinType;
    /**
     * 允许降级获得流，获得音视频不成功 ，降级获得音频
     */
    isAllowDemotionGetStream?: boolean;
    /**
     * 产生session的场景，是主叫产生 或 被叫产生
     */
    produceType?: ProduceTypes;
    isCrossAppkey?: boolean;
    /**
     * 呼叫推送配置
     */
    callPushConfig?: IPushConfig;
    /**
     * 挂断推送配置
     */
    hungupPushConfig?: IPushConfig;
}
interface IRCTrackBitrate {
    /**
     * 最大码率
     */
    max: number;
    /**
     * 最小码率
     */
    min: number;
    /**
     * 上行起始码率
     */
    start?: number;
}
/**
 * RCCallClient call方法的传参
 */
interface IRCCallParams {
    targetId: string;
    /**
     * 音频 or 音视频, 默认音频
     */
    mediaType: RCCallMediaType;
    /**
     * session上要注册的监听事件
     */
    listener: ISessionListener;
    /**
     * 组织 Id，可选
     */
    channelId?: string;
    /**
     * 用于获取己方媒体资源的参数
     */
    constraints?: {
        video?: ICameraVideoProfile;
        audio: IMicphoneAudioProfile;
    };
    /**
     * 消息的扩展信息
     */
    extra?: string;
    /**
    * 对方显示通知的标题
    * @deprecated - version 5.1.2
    */
    pushTitle?: string;
    /**
     * 对方显示的通知内容
     * @deprecated - version 5.1.2
     */
    pushContent?: string;
    /**
     * 设置码率
     */
    bitrate?: {
        video?: IRCTrackBitrate;
        audio?: number;
    };
    /**
     * 是否为跨 appkey 通话
     */
    isCrossAppkey?: boolean;
}
interface IMediaStreamConstraints {
    video?: ICameraVideoProfile;
    audio?: IMicphoneAudioProfile;
}
/**
 * RCCallClient callInGroup方法的传参
 */
interface IRCCallInGroupParams {
    targetId: string;
    userIds: string[];
    mediaType: RCCallMediaType;
    /**
     * session上要注册的监听事件
     */
    listener: ISessionListener;
    /**
     * 组织 Id，可选
     */
    channelId?: string;
    /**
     * 用于获取己方媒体资源的参数
     */
    constraints?: IMediaStreamConstraints;
    /**
     * 消息的扩展信息
     */
    extra?: string;
    /**
     * 对方显示通知的标题
     * @deprecated - version 5.1.2
     */
    pushTitle?: string;
    /**
      * 对方显示的通知内容
      * @deprecated - version 5.1.2
      */
    pushContent?: string;
    /**
     * 设置码率
     */
    bitrate?: {
        video?: IRCTrackBitrate;
        audio?: number;
    };
}

interface IEndSummary {
    /**
     * 通话类型
     */
    conversationType: ConversationType;
    /**
     * 多组织 ID
     */
    channelId: string;
    /**
     * 目标 ID
     */
    targetId: string;
    /**
     * 通话媒体类型
     */
    mediaType: RCCallMediaType;
    /**
     * 通话开始时间戳
     */
    beginTimestamp: number;
    /**
     * 通话结束时间戳
     */
    endTimestamp: number;
    /**
     * 通话时间
     */
    duration: number;
    /**
     * 通话结束原因
     */
    endReason: RCCallEndReason;
}
interface IUserProfile {
    /**
     * 用户名
     */
    name?: string;
    /**
     * 用户头像地址
     */
    portraitUri?: string;
    /**
     * user info 中附加信息
     */
    extra?: string;
}
/**
 * 通话发起者信息
 */
interface ISenderInfo extends IUserProfile {
    /**
     * 发起者 userId
     */
    userId: string;
}
interface IUserData extends IUserProfile {
    /**
     * 用户 ID
     */
    userId: string;
    /**
     * 用户 状态
     */
    state: RCCallUserState;
    /**
     * 是否是通话发起者
     */
    isCaller: boolean;
    /**
     * 是否是远端用户
     */
    isRemote: boolean;
    /**
     * 用户 deviceId
     * 主要用于记录远端的用户的 deviceId, 用于处理多端消息
     */
    deviceId?: string;
}
interface IUserStateChangeInfo {
    /**
     * 用户数据
     */
    user: IUserData;
    /**
     * 挂断原因（ user.state 为 RCCallUserState.NONE 时返回）
     */
    reason?: RCCallEndReason;
}
interface IStateChangeInfo {
    /**
     * 状态
     */
    state: RCCallSessionState;
    /**
     * state 为 RCCallSessionState.END 时返回
     */
    reason?: RCCallEndReason;
}
declare type IInvitedUsers = ISenderInfo;
interface IMemberModifyInfo {
    /**
     * 发起者信息
     */
    sender: ISenderInfo;
    /**
     * 被邀请用户 ID 列表
     */
    invitedUsers: IInvitedUsers[];
}
interface IMediaModifyInfo {
    /**
     * 发起者信息
     */
    sender: ISenderInfo;
    /**
     * 修改后的媒体类型
     */
    mediaType: RCCallMediaType;
}
interface ICallStateMachineWatchers {
    /**
     * 用户状态变更
     * @param info
     */
    onUserStateChange: (info: IUserStateChangeInfo) => void;
    /**
     * 房间状态变更
     * @param info
     */
    onStateChange: (info: IStateChangeInfo) => void;
    /**
     * 收到响铃
     * @param sender 发起用户信息
     */
    onRinging: (sender: ISenderInfo) => void;
    /**
     * 收到接听
     * @param sender 发起用户信息
     */
    onAccept: (sender: ISenderInfo) => void;
    /**
     * 收到挂断
     */
    onHungup: (sender: ISenderInfo, reason: RCCallEndReason) => void;
    /**
     * 收到人员变更
     * @param sender 发起用户信息
     */
    onMemberModify: (info: IMemberModifyInfo) => void;
    /**
     * 收到通话类型变更
     * @param sender 发起用户信息
     */
    onMediaModify: (info: IMediaModifyInfo) => void;
    /**
     * 是否跨appkey
     * @param ifCross 是否为跨appkey通信
     */
    crossAppkey: (ifCross: boolean) => void;
}
/**
 * 发送邀请时的可选项
 */
interface IInviteOptions {
    /**
     * 消息的扩展信息
     */
    extra?: string;
    /**
     * 移动端推送配置
     */
    pushConfig?: IPushConfig;
    /**
     * @deprecated 自 5.1.2 版本废弃，请使用 `pushConfig` 属性代替
     */
    pushTitle?: string;
    /**
     * @deprecated 自 5.1.2 版本废弃，请使用 `pushConfig` 属性代替
     */
    pushContent?: string;
}

/**
 * 注释
 * TODO
 */
declare enum MsgCallStatus {
    OUTGOING = 1,
    INCOMING = 2,
    RINGING = 3,
    CONNECTED = 4,
    IDLE = 5,
    ACCEPTED = 6
}

interface IOfflineRecord {
    channelId: string;
    conversationType: ConversationType;
    targetId: string;
    mediaType: RCCallMediaType;
    callId: string;
    inviterId: string;
    endReason: RCCallEndReason;
    beginTimestamp: number;
    endTimestamp: number;
    duration: number;
}

interface ISendBaseOptions {
    /**
     * 组织 ID
     */
    channelId: string;
    /**
     * 会话类型
     */
    conversationType: ConversationType;
    /**
     * 目标 ID (单聊：对方 Id;群聊： 群组 Id)
     */
    targetId: string;
}
interface IExistedUserPofiles {
    /**
     * 用户 ID
     */
    userId: string;
    /**
     * 通话类型
     */
    mediaType: RCCallMediaType;
    /**
     * 与移动端一致的通话状态
     */
    callStatus: MsgCallStatus;
    /**
     * PC 端 mediaId 直接传 userId, mediaId iOS 需要解出来渲染视图用。
     */
    mediaId?: string;
}
interface IMsgListener {
    onInvite?: (msg: IReceivedMessage) => void;
    onRinging?: (msg: IReceivedMessage) => void;
    onAccept?: (msg: IReceivedMessage) => void;
    onMemberModify?: (msg: IReceivedMessage) => void;
    onMediaModify?: (msg: IReceivedMessage) => void;
    onHungup?: (msg: IReceivedMessage) => void;
    sendAccept?: (info: {
        callId: string;
    }) => void;
    onOfflineRecord?: (record: IOfflineRecord) => void;
}
interface IInviteMsgOptions extends ISendBaseOptions {
    /**
     * 呼叫 ID（ RTC 房间 ID ）
     */
    callId: string;
    /**
     * 通话媒体类型
     */
    mediaType: RCCallMediaType;
    /**
     * 被邀请人用户 ID 列表
     */
    inviteUserIds: string[];
    /**
     * 扩展信息
     */
    extra: string;
    /**
     * 移动端推送配置
     */
    pushConfig?: IPushConfig;
    /**
      * 跨appkey参数
      */
    roomType?: number;
}
interface IMemberModifyMsgOptions extends ISendBaseOptions {
    /**
     * 呼叫 ID（ RTC 房间 ID ）
     */
    callId: string;
    /**
     * 通话媒体类型
     */
    mediaType: RCCallMediaType;
    /**
     * 被邀请人用户 ID 列表
     */
    inviteUserIds: string[];
    /**
     * 获取会话发起者 Id
     */
    callerId: string;
    /**
     * 当前通话中的所有人，包含未接听用户
     */
    existedUserPofiles: IExistedUserPofiles[];
    /**
     * 当前通话中的所有人，包含未接听用户
     */
    directionalUserIdList: string[];
    /**
     * 扩展信息
     */
    extra: string;
    /**
     * 移动端推送配置
     */
    pushConfig?: IPushConfig;
}
interface IRingingMsgOptions extends ISendBaseOptions {
    /**
     * 呼叫 ID（ RTC 房间 ID ）
     */
    callId: string;
    /**
     * 群呼中需要接收响铃的用户 ID 列表
     */
    userIds?: string[];
}
interface IAcceptMsgOptions extends ISendBaseOptions {
    /**
     * 呼叫 ID（ RTC 房间 ID ）
     */
    callId: string;
    /**
     * 通话媒体类型
     */
    mediaType: RCCallMediaType;
    /**
     * 群呼中需要接收接听消息的用户 ID 列表
     */
    userIds: string[];
}
interface IHungupMsgOptions extends ISendBaseOptions {
    /**
     * 呼叫 ID（ RTC 房间 ID ）
     */
    callId: string;
    /**
     * 挂断原因
     */
    reason: RCCallEndReason;
    /**
     * 群呼中需要接收挂断消息的用户 ID 列表
     */
    userIds: string[];
    /**
     * 移动端推送配置
     */
    pushConfig?: IPushConfig;
}
interface IMediaModifyMsgOptions extends ISendBaseOptions {
    /**
     * 呼叫 ID（ RTC 房间 ID ）
     */
    callId: string;
    /**
     * 通话媒体类型
     */
    mediaType: RCCallMediaType;
    /**
     * 群呼中需要媒体变更消息的用户 ID 列表
     */
    userIds: string[];
}

declare type MsgListenerKeys = keyof IMsgListener;
/**
 * 消息接收处理: 在线消息、离线消息
 * 发送消息处理: 发送不同类型消息封装
 */
declare class CallMessageHandler extends EventEmitter {
    private readonly _context;
    private readonly _runtime;
    private readonly _logger;
    /**
     * 离线消息处理时间间隔
     */
    private readonly _offlineMsgItv;
    private readonly _getStateMachine;
    private _watchers;
    private _userInfo;
    private _msgBufferList;
    private _hadHandleMsgTimer;
    private _offlineRecorder;
    private _deviceId;
    constructor(_context: RTCPluginContext, _runtime: IRuntime, _logger: ILogger, 
    /**
     * 离线消息处理时间间隔
     */
    _offlineMsgItv: number, _getStateMachine: (callId: string) => RCCallStateMachine | null);
    private _onMessage;
    /**
     * 在线消息抛给状态机处理
     */
    private _onRecvOnlineCallMsg;
    /**
     * 消息 buffer 列表处理逻辑
     * 1、每 20ms 检查一次 buffer list
     * 2、取出已经延迟 200 的消息列表进行消费 | 无延迟 200ms 内消息直接递归
     * 3、消费分为 离线消息消费逻辑、在线消息消费逻辑，消费后递归
    */
    private _handleBufferMsgs;
    registerEventListener(listener: IMsgListener): void;
    registerStateMachineEvent(callId: string, funcName: MsgListenerKeys, event: (...args: any[]) => void): void;
    unregisterStateMachineEvent(callId: string): void;
    registerUserInfo(userInfo: IUserProfile): void;
    /**
     * 发送 IM 消息
     */
    private _sendCallMessage;
    /**
     * 发送邀请消息
     */
    sendInvite(options: IInviteMsgOptions): Promise<{
        code: RCCallErrorCode;
        message?: IReceivedMessage | undefined;
    }>;
    /**
     * 发送人员变更消息
     */
    sendMemeberModify(options: IMemberModifyMsgOptions): Promise<{
        code: RCCallErrorCode;
        message?: IReceivedMessage | undefined;
    }>;
    /**
     * 发送响铃消息
     */
    sendRinging(options: IRingingMsgOptions): Promise<{
        code: RCCallErrorCode;
        message?: IReceivedMessage | undefined;
    }>;
    /**
     * 发送同意接听消息
     */
    sendAccept(options: IAcceptMsgOptions): Promise<{
        code: RCCallErrorCode;
        message?: IReceivedMessage | undefined;
    }>;
    /**
     * 发送挂断消息
     */
    sendHungup(options: IHungupMsgOptions): Promise<{
        code: RCCallErrorCode;
        message?: IReceivedMessage | undefined;
    }>;
    /**
     * 发送媒体变更消息
     */
    sendMediaModify(options: IMediaModifyMsgOptions): Promise<{
        code: RCCallErrorCode;
        message?: IReceivedMessage | undefined;
    }>;
}

declare class RCCallStateMachine {
    private readonly _context;
    private readonly _runtime;
    private readonly _logger;
    private readonly _callMsgHandler;
    private readonly _channelId;
    private readonly _conversationType;
    private readonly _targetId;
    private _mediaType;
    private readonly _callId;
    /**
     * 房间状态
     */
    private _sessionState;
    /**
     * 用户状态及信息
     */
    private _userInfo;
    /**
     * 用户计时器映射
     */
    private _userTimers;
    /**
     * 监听器
     */
    private _watchers;
    /**
     * 呼叫超时时间 (单位：毫秒)
     */
    private _callTimeout;
    /**
     * 通话建立开始时间
     */
    private _beginTimestamp;
    /**
     * 通话结束时间
     */
    private _endTimestamp;
    /**
     * 通话结束原因
     */
    private _endReason;
    /**
     * 主叫 ID
     * 发起邀请为当前用户 ID
     * 收到邀请为 senderUserId
     * 收到人员变更邀请为消息体中 callerId
     */
    private _callerId;
    /**
     * 当次通话邀请者 ID
     * 发起邀请为当前用户 ID、收到邀请为 senderUserId、收到人员变更邀请为消息体中 senderUserId
     */
    private _inviterId;
    /**
     * 是否是跨 appkey
     */
    private _isCrossAppkey;
    private _hungupPushConfig?;
    constructor(_context: RTCPluginContext, _runtime: IRuntime, _logger: ILogger, _callMsgHandler: CallMessageHandler, _channelId: string, _conversationType: ConversationType, _targetId: string, _mediaType: RCCallMediaType, _callId: string);
    /**
     * 获取校正后超时时间
     */
    private _getTimeout;
    private _clearTimerById;
    /**
     * 通知 call 层房间状态变更及原因
     */
    private _notifyStateChange;
    /**
     * 通知 call 层人员状态变更及原因
     */
    private _notifyUserStateChange;
    private _otherClientHandle;
    /**
     * 正在通话中，且不是当前已接通用户设备（deviceId）发来的消息
    */
    private _isRemoteInvalidMsg;
    private _onRinging;
    private _onAccept;
    private _onMediaModify;
    private _onHungup;
    /**
     * 注册事件监听
     * @params watchers
     */
    registerEventListener(watchers: ICallStateMachineWatchers): void;
    /**
     * 收到 invite 消息时状态机更新（CallEngine 内部调用）
     * @param message 接收消息
     */
    __onInvite(message: IReceivedMessage): void;
    /**
     * 收到 memberModify 消息时状态机更新（CallEngine 内部调用）
     * @param message 接收消息
     */
    __onMemberModify(message: IReceivedMessage): void;
    /**
     * 处理已有 session ，不允许再接听新会话情况
     */
    __handleInviteInSession(): void;
    /**
     * 主动呼叫 (CallEngine 内部调用)
     * @param userIds 被邀请用户 ID 列表
     * @param extra 消息的扩展信息
     * @param pushConfig 移动端推送配置
     */
    __call(userIds: string[], extra: string | undefined, pushConfig: IPushConfig, isCrossAppkey?: boolean): Promise<{
        code: RCCallErrorCode;
    }>;
    /**
     * 接听
     */
    accept(): Promise<{
        code: RCCallErrorCode;
    }>;
    /**
     * 群呼叫中继续邀请
     * @param userIds 被邀请用户 ID 列表
     */
    invite(userIds: string[], options?: IInviteOptions): Promise<{
        code: RCCallErrorCode;
    }>;
    private _hungupHandle;
    /**
     * 挂断
     */
    hungup(): Promise<{
        code: RCCallErrorCode;
    }>;
    /**
     * 修改通话媒体类型
     * @param mediaType RCCallMediaType.AUDIO 改为音频通话 | RCCallMediaType.AUDIO_VIDEO 改为音视频通话
     */
    changeMediaType(mediaType: RCCallMediaType): Promise<{
        code: RCCallErrorCode;
    }>;
    /**
     * 用户加入通话补偿机制（rtc userJoin 事件触发）
     * 主叫呼叫后，未收到被叫 accept 消息，但收到了 userJoin 同样补偿更新用户、房间状态、呼叫计时器
     */
    userJoin(userIds: string[]): void;
    /**
     * 用户离开通话补偿机制（rtc userLeave、kickOff 事件触发）
     * 通话中远端用户挂断，挂断消息未到，但是监听到 rtc userLeave 同样补偿更新用户、房间状态
     */
    userLeave(userIds: string[]): void;
    /**
     * 远端人员离线通知
     */
    userOffline(userIds: string[]): void;
    /**
     * Call 层己方异常失败后调用的方法
     * 触发时机：音视频服务异常、获取资源失败、加入 RTC 房间失败、发布|订阅失败
     */
    close(reason: RCCallEndReason): void;
    setHungupPushConfig(pushConfig: IPushConfig): void;
    /**
     * 通话唯一标识
     */
    getCallId(): string;
    /**
     * 多组织 ID
     */
    getChannelId(): string;
    /**
     * 目标 ID，单呼对方人员 Id, 群呼群组 Id
     */
    getTargetId(): string;
    /**
     * 获取会话类型
     */
    getConversationType(): ConversationType;
    /**
     * 获取远端成员 ID 列表
     */
    getRemoteUserIds(): string[];
    /**
     * 获取远端成员信息列表
     */
    getRemoteUsers(): IUserData[];
    /**
     * 获取房间状态
     */
    getState(): RCCallSessionState;
    /**
     * 获取人员状态
     */
    getUserState(userId: string): RCCallUserState;
    /**
     * 获取会话发起者 Id
     */
    getCallerId(): string;
    /**
     * 获取当次会话邀请者 Id
     */
    getInviterId(): string;
    /**
     * 获取当前通话媒体类型
     */
    getMediaType(): RCCallMediaType;
    /**
     * 通话挂断后可调用
     */
    getSummary(): IEndSummary;
}

declare enum RCCallLanguage {
    ZH = "zh",
    EN = "en"
}

declare class RCCallClient {
    private _context;
    private readonly _runtime;
    private readonly _logger;
    /**
     * rtc实例
     */
    private readonly _rtcClient;
    /**
     * callEngine层实例
     */
    private readonly _callEngine;
    /**
     * 其它参数
     */
    private _options;
    /**
     * session列表
     */
    private _sessionList;
    /**
     * 移动端呼叫推送配置
     */
    private _callPushConfig?;
    /**
     * 移动端挂断推送配置
     */
    private _hungupPushConfig?;
    constructor(_context: RTCPluginContext, _runtime: IRuntime, _logger: BasicLogger, _options: IRCCallInitOptions);
    /**
     * 监听onInvite
     */
    private _onInvite;
    /**
     * 监听离线消息报告
     * @param record
     * @private
     */
    _onOfflineRecord(record: IOfflineRecord): void;
    /**
     * 注册用户信息。注册后，在发起邀请或挂断等操作时，会将该信息一并发送给对端
     * @param info.name        用户名称
     * @param info.portraitUri 用户头像信息
     * @param info.extra       预留拓展字段
     */
    registerUserInfo(info?: {
        name?: string;
        portraitUri?: string;
        extra?: string;
    }): void;
    /**
     * 跨 App 单呼，发送invite消息，回调回来接收stateMachine, 建session
     * @param params.targetId 被呼叫一方的用户 id 必填
     * @param params.mediaType 音频呼叫 or 音视频呼叫  必填
     * @param params.listener (session上的监听) 必填
     * @param params.constraints 获取音频或音视频资源时的参数 可选
     * @param params.channelId 组织 Id 可选
     * @param params.extra 消息扩展信息
     * @param params.bitrate 需要设置的码率参数
     */
    startCrossCall({ targetId, mediaType, listener, constraints, channelId, extra, pushTitle, pushContent, bitrate, }: IRCCallParams): Promise<{
        code: RCCallErrorCode;
        session?: RCCallSession;
    }>;
    /**
     * 发起单人呼叫
     * @param params.targetId 被呼叫一方的用户 id 必填
     * @param params.mediaType 音频呼叫 or 音视频呼叫  必填
     * @param params.listener (session上的监听) 必填
     * @param params.constraints 获取音频或音视频资源时的参数 可选
     * @param params.channelId 组织 Id 可选
     * @param params.extra 消息扩展信息
     * @param params.bitrate 需要设置的码率参数
     */
    call({ targetId, mediaType, listener, constraints, channelId, extra, pushTitle, pushContent, bitrate, }: IRCCallParams): Promise<{
        code: RCCallErrorCode;
        session?: RCCallSession;
    }>;
    private __call;
    /**
     * 发起群组呼叫
     * @param params.targetId 群组 Id 必填
     * @param params.userIds 被呼叫的群内成员 Id 必填
     * @param params.mediaType 音频呼叫 or 音视频呼叫 必填
     * @param params.listener (session上的监听) 必填
     * @param params.constraints 获取音频或音视频资源时的参数 可选
     * @param params.channelId 组织 Id 可选
     * @param params.extra 消息扩展信息 可选
     * @param params.bitrate 需要设置的码率参数
     */
    callInGroup({ targetId, userIds, mediaType, listener, constraints, channelId, extra, pushTitle, pushContent, bitrate, }: IRCCallInGroupParams): Promise<{
        code: RCCallErrorCode;
        session?: RCCallSession;
    }>;
    /**
     * 调RTC API 获得本地流
     */
    private _getLocalTrackCore;
    private _getLocalTrack;
    /**
     * 从sessionList删除某个session
     */
    private _removeSession;
    /**
     * 获取己方其他端加入通话（已加入 RTC 房间）的用户信息
     */
    getJoinedRoomInfo(): Promise<{
        code: RCCallErrorCode;
        data?: IRTCJoinedInfo[];
    }>;
    /**
     * 设置呼叫、挂断推送数据
     * @param callPushConfig 呼叫推送配置
     * @param hungupPushConfig 挂断推送配置
     * @description callLib 会内置 IPushConfig 中 pushData 的赋值，业务层无需关注 pushData 字段值
     */
    setPushConfig(callPushConfig: IPushConfig, hungupPushConfig: IPushConfig): {
        code: RCCallErrorCode.STATE_MACHINE_EXIT | RCCallErrorCode.SEND_MSG_ERROR | RCCallErrorCode.REJECTED_BY_BLACKLIST | RCCallErrorCode.NOT_IN_GROUP | RCCallErrorCode.GET_LOCAL_AUDIO_TRACK_ERROR | RCCallErrorCode.GET_LOCAL_VIDEO_TRACK_ERROR | RCCallErrorCode.GET_LOCAL_AUDIO_AND_VIDEO_TRACK_ERROR | RCCallErrorCode.JOIN_ROOM_ERROR | RCCallErrorCode.AUDIO_PUBLISH_ERROR | RCCallErrorCode.VIDEO_PUBLISH_ERROR | RCCallErrorCode.AUDIO_AND_VIDEO_PUBLISH_ERROR | RCCallErrorCode.QUERY_JOINED_USER_INFO_ERROR | RCCallErrorCode.MISSING_VIDEO_TRACK_ERROR | RCCallErrorCode.UNPUBLISH_VIDEO_ERROR | RCCallErrorCode.CONVERSATION_NOT_GROUP_ERROR | RCCallErrorCode.NOT_IN_ROOM_ERROR | RCCallErrorCode.PARAM_ERROR | RCCallErrorCode.MISSING_AUDIO_TRACK_ERROR | RCCallErrorCode.SESSION_ENDED;
    } | undefined;
}

declare const installer: IPluginGenerator<RCCallClient, IRCCallInitOptions>;

export { IEndSummary, IInvitedUsers, IMediaStreamConstraints, IMuteUser, IOfflineRecord, IPushConfig, IRCCallInGroupParams, IRCCallInitOptions, IRCCallParams, ISenderInfo, ISessionListener, RCCallClient, RCCallEndReason, RCCallErrorCode, RCCallLanguage, RCCallMediaType, RCCallSession, RCCallSessionState, RCCallUserState, installer };
