import { DeviceDescRsp } from '../playback.type';
import { EventQueryRsp } from '../playback.type';
import { PropertiesMap as PropertiesMap_2 } from './thingModel.type';
import { RecordQueryRsp } from '../playback.type';
import { ThingTSL as ThingTSL_2 } from './thingModel.type';

/**
 * 帐号类型
 * @public
 */
declare enum AccountTypeEnum {
    /**
     * 用户名
     */
    USERNAME = "1",
    /**
     * 手机号
     */
    MOBILE = "2",
    /**
     * 邮箱
     */
    EMAIL = "3",
    /**
     * 一键登录
     */
    ONE_KEY = "4",
    /**
     * oauth2第三方登录
     */
    THIRD_LOGIN = "6"
}

/**
 * 请求接口异常
 * @public
 */
declare class ApiRequestFailedException extends RuntimeException {
    constructor(message: string);
    get name(): string;
}

/**
 * app配置选项
 * @public
 */
declare class AppKeyConfig {
    /**
     * 数据中心服务协议
     */
    dataCenterScheme?: ServerSchemeEnum;
    /**
     * 数据中心服务域名
     */
    dataCenterDomain?: string;
    /**
     * 数据中心服务域名类型
     */
    dataCenterDomainType?: DataCenterDomainTypeEnum;
    /**
     * 自动加上AK
     */
    domainAutoWidthAK?: boolean;
    /**
     * 信令协议
     */
    signalingScheme?: ServerSchemeEnum;
    /**
     * 信令域名
     */
    signalingDomain?: string;
    /**
     * STUN服务地址
     */
    stunAddress?: string;
    /**
     * 控制台创建的应用key
     */
    appKey: string;
    /**
     * 控制台创建的应用Secret
     */
    appSecret: string;
}

/**
 * 音频编码类型
 * @public
 */
declare enum AudioEncodeTypeEnum {
    NONE = "NONE",
    PCM = "PCM",
    PCMA = "PCMA",
    PCMU = "PCMU",
    G726 = "G726",
    G722 = "G722",
    AAC = "AAC",
    OPUS = "opus",
    MP3 = "MP3",
    VORBIS = "VORBIS"
}

/**
 * 音频元信息
 * @public
 */
declare type AudioMetaInfo = {
    codec: string;
    /**
     * 编码方式
     */
    codecType: AudioEncodeTypeEnum;
    /**
     * 采样率
     */
    audioSampleRate: number;
    /**
     * 通道数（单双通道）
     */
    channelCount: number;
};

/**
 * 音频渲染器类型
 * @public
 */
declare type AudioRenderType = HTMLVideoElement | IAudioRender | null | undefined;

/**
 * 批量删除结果返回
 *
 * @public
 */
declare type BatchDeleteRsp = {
    /**
     * 删除成功或失败
     */
    count?: number;
};

/**
 * 发起者取消分享
 *
 * @param recordIdList - 分享记录列表
 * @public
 */
declare function cancelShare(recordIdList: number[]): Promise<void>;

/**
 * 设备平台类型
 * @public
 */
declare enum CloudPlatformTypeEnum {
    /**
     * 通用版
     */
    COMMON = 0,
    /**
     * 专属版
     */
    SPECIAL = 1,
    /**
     * 局域网设备
     */
    LAN = 2
}

/**
 * 被分享者同意或拒绝分享
 *
 * @param recordIdList - 分享记录列表
 * @param agree - 0（表示不同意）；1（表示同意）。
 * @public
 */
declare function confirmShare(recordIdList: number[], agree: number): Promise<void>;

/**
 * 国家
 * @public
 */
declare class Country {
    /**
     * 区号
     */
    code: string;
    /**
     * 拼音
     */
    pinyin: string;
    /**
     * 三位字母标识
     */
    isoCode: string;
    /**
     * 地区名称
     */
    areaName: string;
    /**
     * 两位字母标识
     */
    domainAbbreviation: string;
    constructor(code: string, pinyin: string, isoCode: string, areaName: string, domainAbbreviation: string);
}

/**
 * 数据中心域名类型
 * @public
 */
declare enum DataCenterDomainTypeEnum {
    DNMS = "DNMS",
    GATEWAY = "GATEWAY"
}

/**
 * DataChannel通道状态
 * @public
 */
declare enum DataChannelStateEnum {
    STATE_IDLE = 0,
    STATE_SUCCESS = 1,
    STATE_ERROR = 2
}

/**
 *事件或消息最新数据返回
 * @public
 */
declare type DeviceDescRsp_2 = {
    /**
     * 最新一条数据开始时间
     */
    latestBeginTime: number;
};

/**
 * 设备配置维度
 * @public
 */
declare enum DeviceEntityDimensionEnum {
    /**
     * 设备维度类型
     */
    DEVICE = 0,
    /**
     * 用户设备类型
     */
    USER = 2
}

/**
 * 设备配置
 * @public
 */
declare enum DeviceEntityEnum {
    /**
     * 直播策略
     */
    LIVE_PLAY_STRATEGY = 1000,
    /**
     * 消息推送设置
     */
    MSG_PUSH_SETTING = 1003,
    /**
     * PTZ预置位列表
     */
    PTZ_PRESET_LIST = 1004,
    /**
     * 播放时长限制
     */
    LIVE_PLAY_DURATION_LIMIT = 1008
}

/**
 * 获取设备事件描述参数（查最新一条数据时间，做显示小红点使用）
 * @public
 */
declare type DeviceEventDescReq = IDeviceDescReq & {
    /**
     * 多目指定镜头时填写
     */
    lensId?: number;
    /**
     * 事件类型
     */
    eventType?: number;
};

/**
 * 获取设备消息描述参数（查最新一条数据时间，做显示小红点使用）
 * @public
 */
declare type DeviceMsgDescReq = IDeviceDescReq & {
    /**
     * 多目指定镜头时填写
     */
    lensId?: number;
    /**
     * 物模型事件或属性标识，非必填
     */
    identifier?: number;
};

/**
 * 设备节点类型
 * @public
 */
declare enum DeviceNodeTypeEnum {
    /**
     * 设备
     */
    DEVICE = "DEVICE",
    /**
     * 网关
     */
    GATEWAY = "GATEWAY"
}

/**
 * 设备所属类型
 * @public
 */
declare enum DeviceOwnTypeEnum {
    /**
     * 分享
     */
    SHARED = 0,
    /**
     * 自有
     */
    OWNED = 1
}

/**
 * 设备已分享数量
 * @public
 *
 */
declare interface DeviceSharedCount {
    /**
     * 昵称
     */
    nickName?: string;
    /**
     * 设备唯一ID
     */
    iotId: string;
    /**
     * 产品KEY
     */
    productKey: string;
    /**
     * 设备序列号
     */
    deviceName: string;
    /**
     * 已分享数量
     */
    shareCount: number;
}

/**
 *
 * 分享状态
 * @public
 */
declare enum DeviceSharedStatusEnum {
    /**
     * 表示初始化
     */
    INIT = -1,
    /**
     * 表示同意
     */
    ACCEPTED = 0,
    /**
     * 表示拒绝
     */
    REFUSED = 1,
    /**
     * 表示取消
     */
    CANCELED = 2,
    /**
     * 表示过期
     */
    EXPIRED = 3,
    /**
     * 表示抢占
     */
    GRABED = 4,
    /**
     * 表示删除
     */
    DELETED = 5,
    /**
     * 表示发起者已解绑
     */
    UNBIND = 6,
    /**
     * 表示异常
     */
    ERROR = 99
}

/**
 * 设备分享的用户
 * @public
 */
declare interface DeviceSharedUser {
    /**
     * 分享记录id
     */
    recordId: number;
    /**
     * 分享批次ID
     */
    batchId: number;
    /**
     * 分享记录状态
     */
    status: DeviceSharedStatusEnum;
    /**
     * 被分享用户id
     */
    receiverIdentityId: number;
    /**
     * 被分享用户名
     */
    receiverAlias: string;
    /**
     * 权限列表
     */
    permissionList: ShareDevicePermissionEnum[];
}

/**
 * 设备状态
 * @public
 */
declare enum DeviceStatusEnum {
    /**
     * 未知
     */
    UNKNOWN = -1,
    /**
     * 未激活
     */
    NOT_ACTIVE = 0,
    /**
     * 在线
     */
    ONLINE = 1,
    /**
     * 休眠
     */
    SLEEP = 2,
    /**
     * 离线
     */
    OFFLINE = 3,
    /**
     * 禁用
     */
    DISABLE = 8
}

/**
 * 设备类型
 * @public
 */
declare enum DeviceThingTypeEnum {
    /**
     * 设备
     */
    DEVICE = "DEVICE"
}

/**
 * 唤醒休眠设备
 * @param iotId - 设备的唯一标识符。
 * @internal
 */
declare function deviceWakeUp(iotId: string): Promise<void>;

/**
 * 设备工作模式
 * @public
 */
declare enum DeviceWorkModeEnum {
    /**
     * 低功耗设备，代理模式，注意只有支持低功耗保活连接的设备才需要设置此模式，设置了此模式之后必须和wifi 芯片上的 lowPwrSDK配合才能工作
     */
    XS_IOT_WORK_MODE_LOWPOWER_PROXY = "1",
    /**
     * 长上电设备，正常链接模式（iotsdk和streamsdk运行在一个进程中）
     */
    XS_IOT_WORK_MODE_LONG_TIME_POWER = "2",
    /**
     * 低功耗设备，iotsdk和streamsdk分离模式，iotsdk运行在wifi或4g芯片上维持信令长连接，streamsdk运行在主控芯片上
     */
    XS_IOT_WORK_MODE_LOWPOWER_SEPARATE = "3",
    /**
     * 低功耗设备，iotsdk和streamsdk运行在主控芯片上，wifi或4g芯片上仅维持简单心跳保活，支持远程唤醒
     */
    XS_IOT_WORK_MODE_LOWPOWER_KEEPLIVE = "4"
}

/**
 * 事件批量删除
 *
 * @param iotId - 设备ID
 * @param eventList - 事件列表
 * @public
 */
declare function eventBatchDelete(iotId: string, eventList: TimelineEventInfo[]): Promise<any>;

/**
 * 事件批量删除事件
 * @public
 */
declare type EventBatchDeleteReq = {
    /**
     * 设备唯一ID
     */
    iotId: string;
    /**
     * 事件ID，多个
     */
    eventIds: number[];
    /**
     * 镜头ID，多目设备使用
     */
    lensId?: number;
};

/**
 * 查询录制事件
 *
 * @param params - 查询参数
 * @public
 */
declare function eventQuery(params: EventQueryReq): Promise<EventQueryRsp>;

/**
 * 事件列表查询参数
 * @public
 */
declare type EventQueryReq = {
    /**
     * 设备唯一ID
     */
    iotId: string;
    /**
     * 查询开始时间。单位毫秒。
     */
    beginTime: number;
    /**
     * 查询结束时间。单位毫秒。
     */
    endTime: number;
    /**
     * 分页
     */
    pageSize: number;
    /**
     * 事件类型。不传值表示全部。；1（表示移动侦测）；2（表示声音侦测）；3（表示人形侦测）。
     */
    eventTypes?: number[];
    /**
     * 自定义上报事件的标识符
     */
    identifiers?: number[];
    /**
     * 多目设备区分镜头
     */
    lensId?: number;
};

/**
 * 事件列表返回
 * @public
 */
declare type EventQueryRsp_2 = {
    eventList: TimelineEventInfo[];
    /**
     * 下一页是否有效
     */
    nextValid: boolean;
    /**
     * 下一页结束时间
     */
    nextEndTime?: number;
};

/**
 * 事件类型
 * @public
 */
declare enum EventTypeEnum {
    /**
     * 未知
     */
    UNKNOWN = -999,
    /**
     * 自定义
     */
    CUSTOM_MSG = -128,
    /**
     * 智能告警
     */
    INTELLIGENT_ALARM = 0,
    /**
     * 移动侦测
     */
    MOVING_CHECK = 1,
    /**
     * 声音侦测
     */
    SOUND_CHECK = 2,
    /**
     * 人形侦测
     */
    HUMAN_CHECK = 3,
    /**
     * 宠物侦测
     */
    PET_CHECK = 4,
    /**
     * 越界侦测
     */
    CROSS_LINE = 5,
    /**
     * 区域入侵侦测
     */
    REGIONAL_INVASION = 6,
    /**
     * 跌倒检测
     */
    FALL_CHECK = 7,
    /**
     * 人脸检测
     */
    FACE_CHECK = 8
}

/**
 * 获取网关子设备请求参数
 * @public
 */
declare type GatewaySubListReq = {
    /**
     * 设备信息
     */
    deviceInfo: ISimpleDeviceInfo;
    /**
     * 页码
     */
    pageNo: number;
    /**
     * 每页返回列表项数量
     */
    pageSize: number;
    /**
     * 设备分组ID
     */
    groupId?: number;
};

/**
 * 国标设备信息
 * productKey + deviceName 与 iotId 二选一
 * 参数传入示例： productKey + deviceName + channelNo   或  iotId +  channelNo
 * @public
 */
declare interface GBDeviceInfo {
    /**
     * 设备型号
     */
    productKey?: string;
    /**
     * 设备序列号
     */
    deviceName?: string;
    /**
     * 设备ID
     */
    iotId?: string;
    /**
     * 设备通道号
     */
    channelNo: string;
}

/**
 * 生成分享用的二维码(30min有效)
 * @public
 *
 * @param iotIdList - 要分享的设备列表。一次最多20
 * @param permissionList - 权限列表
 */
declare function generateShareQrCode(iotIdList: string[], permissionList: ShareDevicePermissionEnum[]): Promise<GenerateShareQrCodeRsp>;

/**
 * 分享二维码内容接口返回
 * @public
 */
declare interface GenerateShareQrCodeRsp {
    /**
     * 二维码内容
     */
    qrKey: string;
    /**
     * 失效时间
     */
    expireTime: number;
    /**
     * 失败设备列表
     */
    failList?: ShareFailedDevice[];
}

/**
 * 获取用户所在国家或区域
 * @returns
 * @public
 */
declare function getCountry(): Country | undefined;

/**
 * 获取设备详细
 * 第三方可能用自己的设备列表，只有iotId,productKey,deviceName 需要请求数据用于后续业务开发
 *
 * @param sampleDeviceList - 基础设备列表  可能只有iotId,productKey,deviceName
 * @public
 */
declare function getDeviceDetail(sampleDeviceList: ISimpleDeviceInfo[]): Promise<PlayDeviceInfo[]>;

/**
 * 获取设备事件描述（查最新一条数据时间，做显示小红点使用）
 *
 * @param descReq - 查询参数
 * @public
 */
declare function getDeviceEventDesc(descReq: DeviceEventDescReq): Promise<DeviceDescRsp>;

/**
 * 设备列表
 * @param deviceListReq - 设备列表请求参数
 * @returns
 * @public
 */
declare function getDeviceList(deviceListReq: IDeviceListReq): Promise<IDeviceListResp>;

/**
 * 获取设备消息描述（查最新一条数据时间，做显示小红点使用）
 *
 * @param descReq - 查询参数
 * @public
 */
declare function getDeviceMsgDesc(descReq: DeviceMsgDescReq): Promise<DeviceDescRsp>;

/**
 * 获取设备状态
 * @param iotId - 设备ID
 * @returns 设备状态 DeviceStatusEnum
 * @public
 */
declare function getDeviceStatus(iotId: string): Promise<DeviceStatusEnum>;

/**
 * 获取网关子设备
 * @param subListReq - 获取网关子设备列表请求参数
 * @returns
 * @public
 */
declare function getGatewaySubList(subListReq: GatewaySubListReq): Promise<IDeviceListResp>;

/**
 * 获取语言
 * @returns
 * @public
 */
declare function getLocale(): String;

/**
 * 根据图片ID获取图片地址
 * @public
 */
declare type GetPictureReq = {
    /**
     * 平台为设备颁发的ID，设备的唯一标识符。
     */
    iotId: string;
    /**
     * 图片ID列表。最大500
     */
    pictureIdList: string[];
    /**
     * 多目摄像头时候填写
     */
    lensId?: number;
    /**
     * 不填或0：消息中心，1：事件中心
     */
    datasource?: string;
};

/**
 * 批量获取图片返回
 * @public
 */
declare type GetPictureRsp = {
    pictureList: GetPictureRspItem[];
};

/**
 * 图片信息
 * @public
 */
declare type GetPictureRspItem = {
    /**
     * 图片地址
     */
    pictureUrl: string;
    /**
     * 图片ID
     */
    pictureId: string;
};

/**
 * 获取当前数据中心ID
 * @returns
 * @public
 */
declare function getRegionId(): number;

/**
 * 获取接入区域（国内或海外）
 * @returns
 * @public
 */
declare function getRegionType(): RegionTypeEnum;

/**
 * 查询用户下设备的分享数量(初始化和接受状态)
 *
 * @param getSharedCountReq - 请求参数
 * @public
 */
declare function getSharedCountList(getSharedCountReq: GetSharedCountReq): Promise<GetSharedCountRsp>;

/**
 * 获取设备已分享数量列表参数
 * @public
 *
 */
declare interface GetSharedCountReq {
    /**
     * 当前页号，从1开始的页序号。
     */
    pageNo: number;
    /**
     * 页大小，单页item的数量上限，最大值为200
     */
    pageSize: number;
    /**
     * 设备唯一ID。 可选 传值后,只查当前一个设备
     */
    iotId?: string;
}

/**
 * 设备已分享数量返回
 * @public
 *
 */
declare interface GetSharedCountRsp {
    /**
     * 记录总数量
     */
    total: number;
    /**
     * 分页页码
     */
    pageNo: number;
    /**
     * 分页大小
     */
    pageSize: number;
    /**
     * 设备最大可分享次数
     */
    maxShareCount: number;
    /**
     * 记录列表
     */
    items: DeviceSharedCount[];
}

/**
 * 查询用户下设备当前被分享用户(初始化和接受状态)
 *
 * @param getSharedListReq - 请求参数
 * @public
 */
declare function getSharedUserList(getSharedListReq: GetSharedUserListReq): Promise<GetSharedUserListRsp>;

/**
 * 获取已分享用户列表参数
 * @public
 */
declare interface GetSharedUserListReq {
    /**
     * 设备唯一ID。
     */
    readonly iotId: string;
    /**
     * 当前页号，从1开始的页序号。
     */
    readonly pageNo: number;
    /**
     * 页大小，单页item的数量上限，最大值为200
     */
    readonly pageSize: number;
}

/**
 * 已分享用户返回
 * @public
 */
declare interface GetSharedUserListRsp {
    /**
     * 记录总数量
     */
    readonly total: number;
    /**
     * 分页页码
     */
    readonly pageNo: number;
    /**
     * 分页大小
     */
    readonly pageSize: number;
    /**
     * 记录列表
     */
    readonly items: DeviceSharedUser[];
}

/**
 * 获取分享通知列表
 *
 * @param getShareNoticeListReq - 分享通知请求参数
 * @public
 */
declare function getShareNoticeList(getShareNoticeListReq: GetShareNoticeListReq): Promise<GetShareNoticeListRsp>;

/**
 * 分享列表计数
 * @public
 */
declare interface GetShareNoticeListBatchCount {
    /**
     * 当前批次中所包含的分享记录的数量。例如在一个批次中分享了 10 个设备，那么对应包含有 10 个分享记录。
     */
    recordCount: number;
}

/**
 * 获取分享通知列表请求参数
 * @public
 */
declare interface GetShareNoticeListReq {
    /**
     * 当前页号，从1开始的页序号。
     */
    pageNo: number;
    /**
     * 页大小，单页item的数量上限，最大值为200
     */
    pageSize: number;
    /**
     * 是否按照批次的方式来获取通知列表，默认是NONE。可取值为：NONE（表示不作 groupBy 处理）；BATCH（表示同一批次的分享只会有一条通知）。
     */
    groupBy?: string;
}

/**
 * 分享通知列表返回
 * @public
 *
 */
declare interface GetShareNoticeListRsp {
    /**
     * 记录总数量
     */
    total: number;
    /**
     * 分页页码
     */
    pageNo: number;
    /**
     * 分页大小
     */
    pageSize: number;
    /**
     * 分享记录列表
     */
    data: GetShareNoticeListRspItem[];
}

/**
 * 分享通知返回数据
 * @public
 */
declare interface GetShareNoticeListRspItem extends QueryShareRecordByBatchRspItem {
    batchInfo?: GetShareNoticeListBatchCount;
    initiatorIdentityId: number;
    receiverIdentityId: number;
}

/**
 * 获取录制播放地址
 *
 * @param vodUrlGetReq - 查询参数
 * @public
 */
declare function getVodPlayUrl(vodUrlGetReq: VodUrlGetReq): Promise<VodUrlRsp>;

/**
 * 音频渲染器
 * @public
 */
declare interface IAudioRender {
}

/**
 * 获取设备事件描述参数
 * @public
 */
declare interface IDeviceDescReq {
    /**
     * 平台为设备颁发的ID，设备的唯一标识符。
     */
    iotId: string;
}

/**
 * 平台返回设备信息
 * @public
 */
declare interface IDeviceInfo extends ISampleDeviceInfo {
    /**
     * 设备状态
     */
    status?: DeviceStatusEnum;
    /**
     * 设备所属类型
     */
    readonly owned?: DeviceOwnTypeEnum;
    /**
     * 修改时间
     */
    readonly gmtModified?: number;
    /**
     * 所属机房
     */
    region?: string;
    /**
     * 用户的身份ID。
     */
    readonly identityId?: number;
    /**
     * 产品名称
     */
    readonly productName?: string;
    /**
     * 产品型号
     */
    readonly productModel?: string;
    /**
     * 设备别名
     */
    readonly nickName?: string;
    /**
     * 网络类型
     */
    readonly netType?: string;
    /**
     * 所属分组ID
     */
    readonly groupId?: number;
    /**
     * 分享权限（分享设备）
     */
    readonly sharePermissionList?: ShareDevicePermissionEnum[];
    /**
     * 设备类型
     */
    readonly thingType?: DeviceThingTypeEnum;
    /**
     * 节点类型
     */
    readonly nodeType?: DeviceNodeTypeEnum;
    /**
     * 父节点类型
     */
    readonly parentNodeType?: DeviceNodeTypeEnum;
}

/**
 * 设备列表请求参数
 * @public
 */
declare interface IDeviceListReq {
    /**
     *  页码
     */
    readonly pageNo: number;
    /**
     *  每页数据条数
     */
    readonly pageSize: number;
    /**
     * 设备所属类型
     */
    readonly owned?: DeviceOwnTypeEnum;
    /**
     * 设备分组ID
     */
    readonly groupId?: number;
}

/**
 * 设备列表接口返回数据模型
 * @public
 */
declare type IDeviceListResp = {
    readonly pageNo: number;
    readonly pageSize: number;
    readonly total: number;
    data: PlayDeviceInfo[];
};

/**
 * data channel 接口
 * @public
 */
declare interface IIoTDataChannel {
    /**
     * 设备是否支持dataChannel
     *
     */
    isSupport(): boolean;
    /**
     * 通道是否可用
     *
     */
    isValidChannel(): boolean;
    /**
     * 通道是否正在连接中
     *
     */
    isConnecting(): boolean;
    /**
     * 销毁对象,释放资源
     *
     */
    destroy(): void;
    /**
     * 设置监听
     *
     * @param onDataChannelListener - 监听
     */
    setOnDataChannelListener(onDataChannelListener?: OnDataChannelListener): void;
}

/**
 * 无效状态异常
 * @public
 */
declare class IllegalStateException extends RuntimeException {
    constructor(message: string);
    get name(): string;
}

/**
 * 初始化SDK
 * @param config - 初始配置项
 * @returns
 * @public
 */
declare function init(config: InitConfig): Promise<void>;

/**
 * SDK实始化配置选择
 * @public
 */
declare class InitConfig {
    /**
     * 接入区域（国内或海外）
     */
    regionType: RegionTypeEnum;
    /**
     * 环境
     */
    productEnv: PlatformEnvEnum;
    /**
     * 是否开启日志调试
     */
    debug: boolean;
    /**
     * 通用版App配置项
     */
    appKeyConfig?: AppKeyConfig;
    /**
     * 专属版App配置项
     */
    specialAppKeyConfig?: AppKeyConfig;
}

/**
 * 无效参数异常
 * @public
 */
declare class InvalidArgumentException extends RuntimeException {
    constructor(message: string);
    get name(): string;
}

/**
 * 物模型服务调用返回
 * @public
 */
declare type InvokeServiceRsp = {
    code: number;
    data: any;
};

/**
 * 订阅事件回调
 * @param iotId - 设备ID
 * @param eventType - 事件类型
 * @param data - 数据
 * @public
 */
declare type IPanelEventCallback = (iotId: string, eventType: SubscribeEventTypeEnum, data: unknown) => void;

/**
 * 播放器插件
 * @public
 */
declare interface IPlayerPlug {
    /**
     * 插件可调用方法
     * @param method - 方法名
     */
    supportMethod(method: string): boolean;
    /**
     * 调用插件方法
     * @param method - 方法名
     * @param args - 参数集合
     */
    callMethod<T>(method: string, ...args: any[]): Promise<T | void>;
    /**
     * 销毁
     */
    destroy(): void;
}

/**
 * 自定义插件
 * @public
 */
declare interface IPlayerPlugConstructor {
    new (player: IRTCXWebPlayer, pluginOption?: any): IPlayerPlug;
}

/**
 * SD卡服务相关
 * @public
 */
declare interface IRTCXSDCardPlayback {
    /**
     * 按时间段获取SD卡录制文件
     *
     * @param params - 请求参数
     * @public
     */
    recordTimeQuery(params: SDCardRecordQueryReq): Promise<RecordQueryRsp_2>;
    /**
     * 按文件获取SD卡录制文件
     *
     * @param params - 请求参数 [SDCardRecordQueryReq]
     */
    recordFileQuery(params: SDCardRecordQueryReq): Promise<SDCardRecordFileQueryRsp>;
    /**
     * 按时间段获取事件文件
     *
     * @param params - 请求参数 [SDCardEventQueryReq]
     */
    eventTimeQuery(params: SDCardEventQueryReq): Promise<EventQueryRsp_2>;
    /**
     * 按月查询录制统计
     *
     * @param monthQueryReq - [SDCardRecordMonthQueryReq]
     */
    monthRecordQuery(monthQueryReq: SDCardRecordMonthQueryReq): Promise<MonthQueryRsp>;
}

/**
 * 对外Web播放器接口
 * @public
 */
declare interface IRTCXWebPlayer {
    /**
     * 注册插件
     * @param pluginName - 插件名称
     * @param plugin - 插件实例
     * @param pluginOption - 插件初始化选项
     */
    registerPlugin(pluginName: string | PlayerPluginEnum, pluginConstructor: IPlayerPlugConstructor, pluginOption?: any): void;
    /**
     * 反注册插件
     * @param pluginName - 插件名称
     */
    unregisterPlugin(pluginName: string | PlayerPluginEnum): void;
    /**
     * 获取指定插件
     * @param pluginName - 插件名称
     */
    getPlugin(pluginName: string | PlayerPluginEnum): IPlayerPlug | undefined;
    /**
     * 获取音频渲染器
     */
    getAudioRender(): AudioRenderType;
    /**
     * 获取视频渲染器
     */
    getVideoRender(): VideoRenderType;
    /**
     * 获取播放器Dom根节点
     */
    getRootElement(): Element | null | undefined;
    getMediaMeta(): MediaMetaInfo | undefined;
    getTraceId(): string;
    getConfigOption(): IRTCXWebPlayerOption;
    /**
     * 销毁播放器
     */
    destroy(): Promise<void>;
    /**
     * 播放直播
     */
    play(): Promise<void>;
    /**
     * 暂停播放
     */
    pause(): Promise<void>;
    /**
     * 播放标准流地址
     * @param url - 播放地址或播放地址回调方法
     * @param type - 播放地址类型
     */
    playUrl(url: string | PlayUrlGetter, type: PlayUrlTypeEnum): Promise<void>;
    /**
     * 播放回看
     * @param seekParams - 回看参数
     */
    seek(seekParams: ISeekParam): Promise<void>;
    /**
     * 播放时长
     */
    get duration(): number;
    /**
     * 音量
     */
    volume: number;
    /**
     * 是否静音
     */
    muted: boolean;
    /**
     * 当前时间
     */
    get currentTime(): number;
    /**
     * 回看倍速
     */
    playbackRate: number;
    /**
     * 当前是否正在播放回看
     */
    get isPlayback(): boolean;
    /**
     * 当前是否正在播放设备存储卡回看
     */
    get isPlaySDCard(): boolean;
    /**
     * 添加播放器事件监听
     * @param event - 事件
     * @param listener  - 回调
     */
    on(event: RTCXWebPlayerEventEnum, listener: (...args: any[]) => void): void;
    /**
     * 移除播放器事件监听
     * @param event - 事件
     * @param listener  - 回调
     */
    off(event: RTCXWebPlayerEventEnum, listener: (...args: any[]) => void): void;
}

/**
 * web播放器初始化选项
 * @public
 */
declare interface IRTCXWebPlayerOption {
    /**
     * 播放器播放模式
     */
    playMode?: PlayModeEnum;
    /**
     * 播放器所在父容器（需要有高宽），播放器自适应父容器高度，宽度
     * @public
     */
    videoWrapper: string | HTMLMediaElement;
    /**
     * 播放设备信息，由设备列表接口返回
     * @public
     */
    deviceInfo?: PlayDeviceInfo;
    /**
     * 播放国标设备信息
     * @public
     */
    gbDeviceInfo?: GBDeviceInfo;
    /**
     * 调试日志开关
     */
    debug?: boolean;
    /**
     * 无数据最大等待时长，超时上抛error。单位: 毫秒
     * @public
     */
    bufferWaitTimeMS?: number;
    /**
     * 直播播放限制时长，单位：秒
     * @public
     */
    playLimitDuration?: number;
    /**
     * 流类型，播放主码流或子码流
     * @public
     */
    streamChannelId?: number;
    /**
     * 镜头id 仅当多目设备播放时使用
     * @public
     */
    lensId?: number;
    /**
     * 是否静音播放
     * @public
     */
    muted?: boolean;
    /**
     * 是否播放视频数据：默认 true
     * @alpha
     */
    hasVideo?: boolean;
    /**
     * 是否播放音频数据：默认 true
     * @alpha
     */
    hasAudio?: boolean;
    /**
     * 调试参数
     * @alpha
     */
    disableCMS?: boolean;
    /**
     * 调试参数
     * @alpha
     */
    disableP2P?: boolean;
    /**
     * webrtc拦截
     * @param chunk - 音视频数据
     * @returns 请返回处理后的音视频数据
     */
    webRTCMediaDecodeCallback?: (chunk: RTCEncodedAudioFrame | RTCEncodedVideoFrame) => RTCEncodedAudioFrame | RTCEncodedVideoFrame;
}

/**
 * 基本设备信息
 * @public
 */
declare interface ISampleDeviceInfo extends ISimpleDeviceInfo {
}

/**
 * 设备SD卡图片获取
 * @public
 */
declare interface ISDCardPictureGetter {
    /**
     * 获取SD卡事件缩略图
     *
     * @param picId - 图片ID
     * @param timeoutMS - 超时，毫秒
     * @public
     */
    getPicture(picId: string, timeoutMS: number): Promise<Blob>;
    /**
     * 销毁对象
     * @public
     *
     */
    destroy(): void;
    /**
     * 是否支持SD卡图片下载
     * @public
     */
    isSupport(): boolean;
}

/**
 * 播放回看参数
 * @public
 */
declare type ISeekParam = {
    /**
     * 开始时间
     */
    beginTime: number;
    /**
     * 结束时间（可选）
     */
    endTime?: number;
    /**
     * 是否SD卡回看
     */
    isSDCard: boolean;
    /**
     * seek类型区分文件
     */
    seekType?: SeekTypeEnum;
    /**
     * sd卡文件seek时间偏移量
     */
    seekPos?: number;
    /**
     * sd卡文件名称
     */
    filename?: string;
};

/**
 * 基本设备信息
 * @public
 */
declare interface ISimpleDeviceInfo {
    /**
     * 设备唯一ID
     */
    readonly iotId: string;
    /**
     * 设备型号key
     */
    readonly productKey: string;
    /**
     * 设备激活码
     */
    readonly deviceName: string;
}

/**
 * 物模型对象接口
 * @public
 */
declare interface IThingModelPanel {
    /**
     * 设备信息
     */
    deviceInfo: ISimpleDeviceInfo;
    /**
     * 获取物模型属性
     */
    getThingProperties(): Promise<PropertiesMap>;
    /**
     * 获取物模型模板
     */
    getThingTsl(): Promise<ThingTSL>;
    /**
     * 设置物模型属性
     * @param items - 属性
     * @param lensId - 镜头ID 可行
     */
    setProperties(items: Record<string, any>, lensId?: number): Promise<boolean>;
    /**
     * 设置属性的超时时间，最小5秒
     * @param timeout - 超时时间 单位毫秒
     */
    setPropertiesTimeout(timeoutMS: number): void;
    /**
     * 订阅
     * @param callback - 回调
     */
    subscribe(callback: IPanelEventCallback): void;
    /**
     * 取消订阅
     * @param callback - 回调
     */
    unsubscribe(callback: IPanelEventCallback): void;
    /**
     * 销毁
     */
    destroy(): void;
    /**
     * 是否支持属性【非正式接口】
     * @param identifier - 属性标识
     * @alpha
     */
    supportProperty(identifier: string): Promise<boolean>;
    /**
     * 是否支持服务【非正式接口】
     * @param identifier - 服务标识
     * @alpha
     */
    supportService(identifier: string): Promise<boolean>;
    /**
     *
     * @param identifier - 服务标识
     * @param args - 参数
     * @param hasResponse - 是否有返回数据 默认false
     * @param lensId - 镜头ID
     * @param timeout - 超时时间
     */
    invokeService(identifier: string, args?: Record<string, any>, hasResponse?: boolean, lensId?: number, timeout?: number): Promise<InvokeServiceRsp | void>;
}

/**
 * 用户登录返回
 * @public
 */
declare interface IUserLoginResp {
    accessToken: string;
    userId: number;
    appKey: string;
    tenantId: number;
    accessTokenCreateTime: number;
    accessTokenExpireTime: number;
    refreshToken?: string;
    expireTime?: number;
    nickname?: string;
    account?: string;
    changeRegion?: number;
    regionId?: number;
    regionGatewayDomain?: string;
    regionGatewayProtocol?: string;
}

/**
 * 监听方法
 * @public
 */
declare type Listener = (...args: any[]) => void;

/**
 * 支持语言
 * @public
 */
declare enum LocaleEnum {
    zh_CN = "zh_CN",
    en_US = "en_US",
    fr_FR = "fr_FR",
    de_DE = "de_DE",
    ja_JP = "ja_JP",
    ko_KR = "ko_KR",
    es_ES = "es_ES",
    ru_RU = "ru_RU",
    it_IT = "it_IT"
}

/**
 * 自建帐号OAuth2协议登录
 * @param token - 自建帐号用户token
 * @returns
 * @public
 */
declare function loginByAuth2(authCode: string): Promise<IUserLoginResp>;

/**
 * 一键登录
 * @param token - 第三方平台token
 * @returns
 * @public
 */
declare function loginByOneKey(token: string): Promise<IUserLoginResp>;

/**
 * 帐号密码登录
 * @param account - 帐号
 * @param password - 密码
 * @public
 */
declare function loginByPassword(account: string, password: string): Promise<IUserLoginResp>;

/**
 * 用户token登录
 * @param clientUniqueKey - 获取token用到的调用方自己定义能标识自己客户端的唯一字符
 * @param jwtToken - 用户token
 * @param userId - 用户ID 可选 不传会尝试从jwtToken中解uid字段
 * @param tokenExpireTime - 失效时间，单位：毫秒 可选 不传会尝试从jwtToken中解exp字段
 * @public
 */
declare function loginByToken(clientUniqueKey: string, jwtToken: string, userId?: number, tokenExpireTime?: number): void;

/**
 * 验证码登录
 * @param account - 帐号
 * @param verifyCode - 验证码
 * @public
 */
declare function loginByVerifyCode(account: string, verifyCode: string): Promise<IUserLoginResp>;

/**
 * 退出登录
 * @public
 */
declare function logout(): Promise<void>;

/**
 * 配置缺失异常
 * @public
 */
declare class LostConfigException extends RuntimeException {
    constructor(message: string);
    get name(): string;
}

/**
 * 媒体元信息
 * @public
 */
declare interface MediaMetaInfo {
    video?: VideoMetaInfo;
    audio?: AudioMetaInfo;
}

/**
 * 查询事件统计
 *
 * @param monthQueryReq - 查询参数
 * @public
 */
declare function monthEventQuery(monthQueryReq: MonthQueryReq): Promise<MonthQueryRsp>;

/**
 * 每天数量
 * @public
 */
declare type MonthQueryItem = {
    /**
     * 日期，格式为：2024-09-02
     */
    dateStr: string;
    /**
     * 数量
     */
    count: number;
};

/**
 * 按天统计录制数量请求
 *
 * @public
 */
declare type MonthQueryReq = {
    /**
     * 平台为设备颁发的ID，设备的唯一标识符。
     */
    iotId: string;
    /**
     * beginTime 开始时间，UTC时间戳
     */
    beginTime: number;
    /**
     * 结束时间，UTC时间戳
     */
    endTime: number;
    /**
     * 时区的偏移值，比如：+08:00,+08,+0800
     */
    zoneOffsetId: string;
    /**
     * 多目指定镜头时填写
     */
    lensId?: number;
    /**
     * 事件类型
     */
    eventType?: EventTypeEnum;
    /**
     * 物模型事件或属性标识，非必填
     */
    identifier?: string;
};

/**
 * 按天统计数量返回
 * @public
 */
declare type MonthQueryRsp = {
    dayCntList: MonthQueryItem[];
};

/**
 * 查询录制统计
 *
 * @param monthQueryReq - 查询参数
 * @public
 */
declare function monthRecordQuery(monthQueryReq: MonthQueryReq): Promise<MonthQueryRsp>;

/**
 * 消息批量删除
 *
 * @param iotId - 设备ID
 * @param eventList - 消息列表
 * @public
 */
declare function msgBatchDelete(iotId: string, eventList: TimelineEventInfo[]): Promise<any>;

/**
 * 消息列表（消息中心）
 *
 * @param params - 查询参数
 * @public
 */
declare function msgCenterEventQuery(params: EventQueryReq): Promise<EventQueryRsp>;

/**
 * 消息查询统计
 *
 * @param monthQueryReq - 查询参数
 * @public
 */
declare function msgEventMonthQuery(monthQueryReq: MonthQueryReq): Promise<MonthQueryRsp>;

/**
 * 未实现功能异常
 * @public
 */
declare class NotImplementedException extends RuntimeException {
    constructor(message: string);
    get name(): string;
}

/**
 * DataChannel通道监听器
 * @public
 */
declare interface OnDataChannelListener {
    /**
     * 状态监听
     *
     * @param status - 状态
     * @param code - 扩展状态码
     */
    onStatusChange(status: DataChannelStateEnum): void;
    /**
     * 接收远端发送的数据
     *
     * @param cmdId - 指令：取值 0到1000
     * @param body - 接收的二进制数据
     */
    onData(cmdId: number, body: Uint8Array): void;
}

/**
 * 用户token失效监听
 * @public
 */
declare type OnTokenInvalidListener = (err: RuntimeException) => void;

/**
 * 密码类型
 * @public
 */
declare enum PasswordTypeEnum {
    /**
     * 密码
     */
    PASSWORD = "1",
    /**
     * 邮箱验证码
     */
    EMAIL_CODE = "2",
    /**
     * 手机验证码
     */
    MOBILE_CODE = "3",
    /**
     * 第三方登录code
     */
    AUTH2_CODE = "4"
}

/**
 * 画中画插件方法
 * @public
 */
declare enum PictureInPicturePluginMethodEnum {
    requestPictureInPicture = "requestPictureInPicture",
    pictureInPictureElement = "pictureInPictureElement",
    pictureInPictureEnabled = "pictureInPictureEnabled",
    exitPictureInPicture = "exitPictureInPicture"
}

/**
 * 平台环境
 * @public
 */
declare enum PlatformEnvEnum {
    LOCAL = 0,
    TEST = 1,
    PROD = 2
}

/**
 * 扩展设备信息
 * @public
 */
declare class PlayDeviceInfo implements IDeviceInfo {
    /**
     * 设备是通用版，还是专属版
     * @internal
     */
    platformType: CloudPlatformTypeEnum;
    /**
     * 局域网设备信令地址
     * @internal
     */
    lanSignalAddressInfo?: SignalAddressInfo;
    /**
     * 物模型属性，不要操作
     * @internal
     */
    thingProperties: Record<string, any>;
    iotId: string;
    productKey: string;
    deviceName: string;
    status: DeviceStatusEnum;
    owned: DeviceOwnTypeEnum;
    gmtModified: number;
    region?: string;
    identityId?: number;
    productName?: string;
    productModel?: string;
    nickName?: string;
    netType?: string;
    groupId?: number;
    sharePermissionList?: ShareDevicePermissionEnum[] | undefined;
    thingType: DeviceThingTypeEnum;
    nodeType: DeviceNodeTypeEnum;
    parentNodeType?: DeviceNodeTypeEnum | undefined;
    /**
     * 设备缩略图
     * @public
     */
    thumbnail?: string;
    /**
     * 镜头ID 多目设备使用
     * @public
     */
    lensId?: number;
    constructor(deviceInfo: IDeviceInfo, platformType?: CloudPlatformTypeEnum);
    /**
     * 获取设备显示文案（优先别名）
     * @returns
     */
    getShowName(): string;
    /**
     * 设备镜头数
     */
    get lensCount(): number;
    /**
     * 设备是否支持P2P
     */
    get isSupportP2P(): boolean;
    /**
     * 设备是否支持信令压缩数据
     */
    get isSupportCompressData(): boolean;
    /**
     * 设备工作模式
     */
    get deviceWorkMode(): DeviceWorkModeEnum;
    /**
     * 设备所在平台类型
     * @internal
     */
    get cloudPlatformTypeEnum(): CloudPlatformTypeEnum;
    protected set cloudPlatformTypeEnum(value: CloudPlatformTypeEnum);
    /**
     * 设备SDK支持能力
     */
    supportSdkAbility(thingAbilityEnum: ThingSDKAbilityEnum): boolean;
    /**
     * 是否是专属版设备
     *
     * @returns
     */
    isSpecialDevice(): boolean;
    /**
     * 是否是局域网设备
     *
     * @returns
     */
    isLanDevice(): boolean;
}

/**
 * 播放器内置的插件
 * @public
 */
declare enum PlayerPluginEnum {
    SnapshotPlugin = "SnapshotPlugin",
    ZoomPlug = "ZoomPlug",
    TalkPlug = "TalkPlug",
    PictureInPicturePlug = "PictureInPicturePlug"
}

/**
 * 播放器播放模式
 * @public
 */
declare enum PlayModeEnum {
    /**
     * 播放RTCX平台设备
     */
    DEVICE = 0,
    /**
     * 播放RTCX国标平台设备
     */
    GB_DEVICE = 1,
    /**
     * 播放标准流
     */
    STANDARD = 2
}

/**
 * 根据type地址获取播放地址或SDP
 * @param sdp - 可选，RTC播放时有值
 * @public
 */
declare type PlayUrlGetter = (type: PlayUrlTypeEnum, sdp?: string) => Promise<string>;

/**
 * 播放地址类型
 * @public
 */
declare enum PlayUrlTypeEnum {
    /**
     * hls协议地址，m3u8地址
     */
    HLS = "hls",
    /**
     * WS(S)+FLV 或  HTTP(S)+ FLV
     */
    FLV = "flv",
    /**
     * WS(S)+TS 或  HTTP(S)+ TS
     */
    /**
     * MP4 http(s)地址
     */
    /**
     * webrtc
     */
    WebRTC = "webrtc"
}

/**
 * 设备物模型属性格式
 * @public
 */
declare type PropertiesMap = Record<string, PropertieValue[]>;

/**
 * 物模型属性值格式
 * @public
 */
declare type PropertieValue = {
    /**
     * 属性值
     */
    value: any;
    /**
     * 修改时间
     */
    time: number;
};

/**
 * 批次查询设备分享记录
 *
 * @param queryShareRecordByBatchReq - 批次分享记录查询
 * @public
 */
declare function queryShareRecordByBatch(queryShareRecordByBatchReq: QueryShareRecordByBatchReq): Promise<QueryShareRecordByBatchRsp>;

/**
 * 按批次查询设备分享记录
 * @public
 *
 */
declare interface QueryShareRecordByBatchReq {
    /**
     * 要查询的批次ID
     */
    batchId: number;
    /**
     * 当前页号，从1开始的页序号
     */
    pageNo: number;
    /**
     * 页大小，单页item的数量上限，最大值为200
     */
    pageSize: number;
}

/**
 * 按批次查询分享记录返回
 * @public
 *
 */
declare interface QueryShareRecordByBatchRsp {
    /**
     * 记录总数量
     */
    total: number;
    /**
     * 分页页码
     */
    pageNo: number;
    /**
     * 分页大小
     */
    pageSize: number;
    /**
     * 记录列表
     */
    data: QueryShareRecordByBatchRspItem[];
}

/**
 * 按批次查询分享记录返回数据
 * @public
 */
declare interface QueryShareRecordByBatchRspItem {
    /**
     * 发起分享用户的账号
     */
    initiatorAlias?: string;
    /**
     * 被分享用户的账号
     */
    receiverAlias?: string;
    /**
     * 产品型号
     */
    productKey: string;
    /**
     * 设备许可，就是激活码。按照BATCH查询时，如果批次内有多个记录，此字段不会返回。
     */
    deviceName: string;
    /**
     * 当前用户是否是消息接收者。0（表示当前用户是此消息的发起者）；1（表示当前用户是接收者）。
     */
    isReceiver: number;
    /**
     * 创建时间
     */
    gmtCreate: number;
    /**
     * 修改时间。
     */
    gmtModified: number;
    /**
     * 分享记录唯一标识。按照BATCH查询时，如果批次内有多个记录，此字段不会返回。
     */
    recordId: number;
    /**
     * 分享批次ID。批量分享设备时，同一批次ID相同，客户端可以根据此判断是否为同一批分享，由此做聚合展示等。
     */
    batchId: number;
    /**
     * 状态 。-1:（表示初始化）；0（表示同意）；1（表示拒绝 ）；2（表示取消）；3（表示过期）；4（表示抢占）；5（表示删除）；6（表示发起者已解绑）；99（表示异常）。
     */
    status: DeviceSharedStatusEnum;
    /**
     * 权限列表
     */
    permissionList: ShareDevicePermissionEnum[];
    /**
     * 描述
     */
    description?: string;
}

/**
 * 录制删除
 *
 * @param recordDeleteReq - 查询参数
 * @public
 */
declare function recordDelete(recordDeleteReq: RecordDeleteReq): Promise<any>;

/**
 * 录制删除
 * @public
 */
declare type RecordDeleteReq = {
    /**
     * 平台为设备颁发的ID，设备的唯一标识符。
     */
    iotId: string;
    /**
     * 查询开始时间。单位毫秒。
     */
    beginTime: number;
    /**
     * 查询结束时间。单位毫秒。
     */
    endTime: number;
};

/**
 * 查询录制列表
 *
 * @param params - 查询参数
 * @public
 */
declare function recordQuery(params: RecordQueryReq): Promise<RecordQueryRsp>;

/**
 * 录制列表请求
 * @public
 */
declare type RecordQueryReq = {
    /**
     * 平台为设备颁发的ID，设备的唯一标识符。
     */
    iotId: string;
    /**
     * 查询开始时间。单位毫秒。
     */
    beginTime: number;
    /**
     * 查询结束时间。单位毫秒。
     */
    endTime: number;
    /**
     * 单页数量
     */
    pageSize: number;
    /**
     * 码流类型：0主码流，1辅码流
     */
    streamType?: number;
    /**
     * 录像类型：0 计划录像，1 报警录像，2 主动录像
     */
    recordType?: number;
};

/**
 * 录制列表
 * @public
 */
declare type RecordQueryRsp_2 = {
    /**
     * 云端录像文件列表
     */
    recordFileList: TimelineRecordInfo[];
    /**
     * 下一页是否有效
     */
    nextValid: boolean;
    /**
     * 下一页结束时间
     */
    nextEndTime?: number;
};

/**
 * SDK接入区域
 * @public
 */
declare enum RegionTypeEnum {
    /**
     * 中国大陆
     */
    REGION_CHINA_ONLY = 0,
    /**
     * 海外
     */
    REGION_ALL = 1
}

export declare namespace RTCXAccount {
    export {
        loginByPassword,
        loginByVerifyCode,
        loginByOneKey,
        loginByAuth2,
        loginByToken,
        logout,
        setOnTokenInvalidListener
    }
}

export declare namespace RTCXAccountTypes {
    export {
        AccountTypeEnum,
        PasswordTypeEnum,
        IUserLoginResp,
        OnTokenInvalidListener
    }
}

export declare namespace RTCXCloudPlayback {
    export {
        recordQuery,
        getVodPlayUrl,
        monthRecordQuery,
        recordDelete,
        eventQuery,
        monthEventQuery,
        eventBatchDelete,
        msgCenterEventQuery,
        msgEventMonthQuery,
        getDeviceEventDesc,
        getDeviceMsgDesc,
        msgBatchDelete
    }
}

export declare namespace RTCXCommonTypes {
    export {
        PlatformEnvEnum,
        LocaleEnum,
        RegionTypeEnum,
        DataCenterDomainTypeEnum,
        ServerSchemeEnum,
        Country,
        CloudPlatformTypeEnum,
        Listener,
        RuntimeExceptionCode,
        RuntimeException,
        TokenInvalidException,
        IllegalStateException,
        InvalidArgumentException,
        ApiRequestFailedException,
        NotImplementedException,
        LostConfigException,
        UnsupportFeatureException,
        UnknownException
    }
}

/**
 * dataChannel 公共业务
 * @public
 */
export declare class RTCXDataChannel implements IIoTDataChannel, OnDataChannelListener {
    private TAG;
    protected deviceInfo: PlayDeviceInfo;
    private sendControlInternal;
    private dataChannel?;
    private mOnDataChannelListener?;
    private mWaitQueue;
    private sendContrlTimer;
    private lastSendTime;
    private sendControlQueue;
    /**
     * dataChannel 公共业务
     *
     * @param deviceInfo - 设备信息
     * @param sendControlInternal - 发送信令频率控制
     */
    constructor(deviceInfo: PlayDeviceInfo, sendControlInternal?: number);
    private createChannel;
    private destroyChannel;
    protected on(name: string, callback: Listener): void;
    protected off(name: string, callback: Listener): void;
    protected sendSigCmdData(cmdId: number, reqParams?: any, data?: Uint8Array, timeoutMs?: number): Promise<any>;
    /**
     * 发送自定义数据
     *
     * @param cmdId - 指令，取值需要在0到1000
     * @param data - 二进制数据 最大128KB
     */
    sendCmdData(cmdId: number, data?: Uint8Array): void;
    /**
     * 销毁通道
     */
    destroy(): void;
    /**
     * 是否支持DataChannel
     * @returns
     */
    static isSupport(deviceInfo: PlayDeviceInfo): boolean;
    /**
     * 是否支持DataChannel
     * @returns
     */
    isSupport(): boolean;
    /**
     * 当前通道是否有效
     * @returns
     */
    isValidChannel(): boolean;
    /**
     * 当前通道是否正在连接中
     * @returns
     */
    isConnecting(): boolean;
    /**
     * 设置监听
     *
     * @param onDataChannelListener - 监听回调
     */
    setOnDataChannelListener(onDataChannelListener?: OnDataChannelListener): void;
    private checkSendQueue;
    onStatusChange(status: DataChannelStateEnum): void;
    onData(cmdId: number, body: Uint8Array): void;
}

export declare namespace RTCXDataChannelTypes {
    export {
        DataChannelStateEnum,
        OnDataChannelListener,
        IIoTDataChannel,
        ISDCardPictureGetter
    }
}

export declare namespace RTCXDeviceMgr {
    export {
        getDeviceStatus,
        getDeviceList,
        getDeviceDetail,
        getGatewaySubList,
        setGatewayDeviceRelevance,
        deviceWakeUp,
        unbindAccountAndDev,
        setDeviceNickName
    }
}

export declare namespace RTCXDeviceMgrTypes {
    export {
        DeviceOwnTypeEnum,
        DeviceThingTypeEnum,
        DeviceNodeTypeEnum,
        DeviceWorkModeEnum,
        DeviceStatusEnum,
        IDeviceListReq,
        ISimpleDeviceInfo,
        ISampleDeviceInfo,
        IDeviceInfo,
        SampleDeviceInfo,
        PlayDeviceInfo,
        IDeviceListResp,
        DeviceEntityEnum,
        DeviceEntityDimensionEnum,
        GatewaySubListReq,
        DeviceSharedStatusEnum,
        ShareFailedDevice,
        GenerateShareQrCodeRsp,
        ScanBindByShareQrcodeRsp,
        ShareDevicePermissionEnum,
        ShareAccountAttrTypeEnum,
        ShareDevicesReq,
        ShareDevicesRsp,
        GetShareNoticeListReq,
        GetShareNoticeListBatchCount,
        QueryShareRecordByBatchReq,
        QueryShareRecordByBatchRspItem,
        QueryShareRecordByBatchRsp,
        GetShareNoticeListRspItem,
        GetShareNoticeListRsp,
        GetSharedUserListReq,
        DeviceSharedUser,
        GetSharedUserListRsp,
        GetSharedCountReq,
        DeviceSharedCount,
        GetSharedCountRsp
    }
}

export declare namespace RTCXDeviceShareMgr {
    export {
        generateShareQrCode,
        scanBindByShareQrcode,
        shareDevices,
        cancelShare,
        confirmShare,
        getShareNoticeList,
        queryShareRecordByBatch,
        setSharePermission,
        getSharedUserList,
        getSharedCountList
    }
}

/**
 * 低功耗设备唤醒
 * @public
 */
export declare class RTCXDeviceWakeUpMgr {
    private TAG;
    private id;
    private iotId;
    private wakeupTimeout;
    private checkStatusInterval;
    private timeoutTimer?;
    private checkStatusTimer?;
    private retryWakeupInterval;
    /**
     *
     * @param iotId - 设备唯一ID
     * @param wakeupTimeout - 超时时长 单位:毫秒  默认30_000
     * @param checkStatusInterval - 轮询设备状态频率 单位:毫秒  默认1000
     */
    constructor(iotId: string, wakeupTimeout?: number, checkStatusInterval?: number);
    /**
     * 唤醒设备，等待设备上线
     */
    wakeup(): Promise<void>;
    /**
     * 结束唤醒流程
     */
    stop(): void;
    private doStop;
    private stopCheckStatus;
    private startCheckStatus;
}

export declare namespace RTCXPlaybackTypes {
    export {
        BatchDeleteRsp,
        DeviceDescRsp_2 as DeviceDescRsp,
        IDeviceDescReq,
        DeviceEventDescReq,
        DeviceMsgDescReq,
        EventBatchDeleteReq,
        EventQueryReq,
        EventQueryRsp_2 as EventQueryRsp,
        EventTypeEnum,
        TimelineEventInfo,
        GetPictureReq,
        GetPictureRspItem,
        GetPictureRsp,
        MonthQueryReq,
        MonthQueryItem,
        MonthQueryRsp,
        RecordDeleteReq,
        SDCardRecordFileInfo,
        SDCardRecordFileQueryRsp,
        RecordQueryReq,
        TimelineRecordInfo,
        RecordQueryRsp_2 as RecordQueryRsp,
        SDCardEventQueryReq,
        SDCardRecordMonthQueryReq,
        SDCardRecordQueryReq,
        VodUrlGetReq,
        VodUrlRsp,
        IRTCXSDCardPlayback
    }
}

/**
 * 获取设备SD卡图片
 * @public
 */
export declare class RTCXSDCardPictureGetter extends RTCXDataChannel implements ISDCardPictureGetter {
    /**
     *
     * @param deviceInfo -设备信息
     */
    constructor(deviceInfo: PlayDeviceInfo);
    private getSigRequest;
    getPicture(picId: string, timeoutMS: number): Promise<Blob>;
}

export declare const RTCXSDCardPlayback: IRTCXSDCardPlayback;

export declare namespace RTCXSDKInit {
    export {
        init,
        uninit,
        getRegionId,
        getRegionType,
        getCountry,
        setLocale,
        getLocale,
        setCountry
    }
}

export declare namespace RTCXSDKInitTypes {
    export {
        AppKeyConfig,
        InitConfig
    }
}

export declare namespace RTCXSignalingTypes {
    export {
        SignalAddressInfo
    }
}

/**
 * 物模型
 * @public
 */
export declare class RTCXThingModelPanel implements IThingModelPanel {
    deviceInfo: ISimpleDeviceInfo;
    private realPanel;
    constructor(playDeviceInfo: PlayDeviceInfo);
    supportProperty(identifier: string): Promise<boolean>;
    supportService(identifier: string): Promise<boolean>;
    getThingProperties(): Promise<PropertiesMap_2>;
    setProperties(items: Record<string, any>, lensId?: number): Promise<boolean>;
    setPropertiesTimeout(timeoutMS: number): void;
    getThingTsl(): Promise<ThingTSL_2>;
    invokeService(identifier: string, args?: Record<string, any>, hasResponse?: boolean, lensId?: number, timeout?: number): Promise<InvokeServiceRsp | void>;
    subscribe(callback: IPanelEventCallback): void;
    unsubscribe(callback: IPanelEventCallback): void;
    destroy(): void;
}

export declare namespace RTCXThingModelTypes {
    export {
        ThingSDKAbilityEnum,
        ThingPropertyValue,
        ThingDataBase,
        ThingTSLProfile,
        ThingTSLDataType,
        ThingTSLServiceParam,
        ThingTSLService,
        ThingTSLProperty,
        ThingTSLEvent,
        ThingTSL,
        InvokeServiceRsp,
        SubscribeEventTypeEnum,
        PropertieValue,
        PropertiesMap,
        IPanelEventCallback,
        IThingModelPanel
    }
}

/**
 * 播放器
 * @public
 */
export declare class RTCXWebPlayer implements IRTCXWebPlayer {
    private TAG;
    private playerWrapper;
    private signalingWebSocket?;
    private signalingProxy?;
    private videoRenderWrapper;
    private options;
    private realPlayer;
    private traceId;
    private eventEmitter;
    private rtcLiveStrategy?;
    private isPause;
    private isPlaying;
    private lastSeekParam?;
    private lastUpdateTime;
    private plugins;
    private waitingCheckTimer;
    private videoRenderWrapperId;
    constructor(options: IRTCXWebPlayerOption);
    /**
     * 播放
     * @param url - 播放地址
     * @param type - 地址播放类型
     */
    playUrl(url: string | PlayUrlGetter, type: PlayUrlTypeEnum): Promise<void>;
    private playGBDevice;
    /**
     * 播放
     * @param url - 播放地址或地址获取异步方法
     * @param type - 可选 地址播放类型, 当url为PlayUrlGetter时，从PlayUrlGetter返回值中获取
     */
    private delayplayUrl;
    registerPlugin(pluginName: string, pluginConstructor: IPlayerPlugConstructor, pluginOption?: any): void;
    unregisterPlugin(pluginName: string): void;
    getPlugin(pluginName: string): IPlayerPlug | undefined;
    getAudioRender(): AudioRenderType;
    getVideoRender(): VideoRenderType;
    getRootElement(): Element | null | undefined;
    getMediaMeta(): MediaMetaInfo | undefined;
    getTraceId(): string;
    getConfigOption(): IRTCXWebPlayerOption;
    /**
     * 监听全屏状态变化
     * @param listener - 加调
     */
    static onFullscreenChange(listener: Listener): void;
    /**
     * 移除监听全屏状态变化
     * @param listener - 加调
     */
    static offFullscreenChange(listener: Listener): void;
    /**
     * 全屏
     *
     * @param domElement - Dom元素
     * @public
     */
    static requestFullscreen(domElement: Element): void;
    /**
     * 判断当前是否全屏
     * @public
     */
    static isFullscreen(): boolean;
    /**
     * 浏览器退出全屏
     * @public
     */
    static exitFullscreen(): void;
    on(event: RTCXWebPlayerEventEnum, listener: (...args: any[]) => void): void;
    off(event: RTCXWebPlayerEventEnum, listener: (...args: any[]) => void): void;
    destroy(): Promise<void>;
    play(): Promise<void>;
    pause(): Promise<void>;
    seek(seekParam: ISeekParam): Promise<void>;
    get duration(): number;
    get volume(): number;
    set volume(value: number);
    get muted(): boolean;
    set muted(value: boolean);
    get currentTime(): number;
    get playbackRate(): number;
    get isPlayback(): boolean;
    get isPlaySDCard(): boolean;
    private init;
    private getRtcLiveStrategy;
    private getPlayLimitDuration;
    private createPlayerDom;
    private fixChromeVideoFlashBug;
    private getSignalingWebSocket;
    private getVideoCodec;
    private getAudioCodec;
    private createPlayer;
    private initPlayerListener;
    private onCanPlay;
    private onTimeUpdate;
    private stopWaitingCheck;
    private startWaitingCheck;
    private onPlayerError;
    private onPlayerEnded;
    private destroyPlayer;
}

/**
 * Web播放器事件
 * @public
 */
declare enum RTCXWebPlayerEventEnum {
    /**
     * 初始化完成
     */
    inited = "inited",
    /**
     * 可播放
     */
    canplay = "canplay",
    /**
     * 播放结束
     */
    ended = "ended",
    /**
     * 播放异常
     */
    error = "error",
    /**
     * 播放暂停
     */
    pause = "pause",
    /**
     * 缓冲数据
     */
    waiting = "waiting",
    /**
     * 开始播放
     */
    playing = "playing",
    /**
     * 时间变化
     */
    timeupdate = "timeupdate"
}

export declare namespace RTCXWebPlayerTypes {
    export {
        StreamTypeEnum,
        IPlayerPlugConstructor,
        IPlayerPlug,
        IAudioRender,
        AudioEncodeTypeEnum,
        VideoEncodeTypeEnum,
        VideoMetaInfo,
        AudioMetaInfo,
        MediaMetaInfo,
        ZoomPluginMethodEnum,
        SnapshotPluginMethodEnum,
        TalkPluginMethodEnum,
        PictureInPicturePluginMethodEnum,
        PlayerPluginEnum,
        GBDeviceInfo,
        VideoRenderType,
        AudioRenderType,
        PlayUrlTypeEnum,
        IRTCXWebPlayer,
        PlayModeEnum,
        IRTCXWebPlayerOption,
        SeekTypeEnum,
        ISeekParam,
        RTCXWebPlayerEventEnum,
        PlayUrlGetter
    }
}

/**
 * 异常
 * @public
 */
declare class RuntimeException {
    code: RuntimeExceptionCode;
    message: string;
    constructor(code: RuntimeExceptionCode, message: string);
    get name(): string;
    toString(): string;
}

/**
 * sdk状态码
 * @public
 */
declare enum RuntimeExceptionCode {
    /**
     * 正常
     */
    OK = 0,
    /**
     * 未知
     */
    Unkonwn = 1,
    /**
     * 无效状态
     */
    IllegalState = 2,
    /**
     * 未实现功能
     */
    NotImplemented = 3,
    /**
     * 时间异常
     */
    OutOfTimeRange = 4,
    /**
     * 请求参数异常
     */
    RequestParamInvalid = 5,
    /**
     * 配置缺失
     */
    LostConfig = 6,
    /**
     * 接口请求异常
     */
    ApiRequestFailed = 7,
    /**
     * 不支持能力
     */
    NotSupportFeature = 8,
    /**
     * 对讲路数达到上限
     */
    TalkBusy = 9,
    /**
     * 对讲通道建立失败
     */
    TalkConnectFailed = 10,
    /**
     * P2P通道路数达到上限
     */
    P2PBusy = 11,
    /**
     * 低功耗设备唤醒超时
     */
    WakeUpTimeout = 12,
    /**
     * DataChannel信令返回超时
     */
    DataChannelRspTimeout = 13,
    /**
     * DataChannel信令ID错误
     */
    DataChannelCmdIdError = 14,
    /**
     * DataChannel信令数据长度异常
     */
    DataChannelDataSizeError = 15,
    /**
     * DataChannel无效
     */
    DataChannelInvalid = 16,
    /**
     * DataChannel获取SD卡图片失败
     */
    DataChannelGetSDCardPicError = 17,
    /**
     * DataChannel获取SD卡图片失败
     */
    TokenInvalidError = 18
}

/**
 * 基本设备信息
 * @public
 */
declare class SampleDeviceInfo implements ISampleDeviceInfo {
    readonly iotId: string;
    readonly productKey: string;
    readonly deviceName: string;
    constructor(iotId: string, productKey: string, deviceName: string);
}

/**
 * 通过扫描二维码绑定设备(分享设备)
 *
 * @param qrKey - 设备ID生成的二维码内容信息
 * @public
 */
declare function scanBindByShareQrcode(qrKey: string): Promise<ScanBindByShareQrcodeRsp>;

/**
 * 扫码分享返回结果
 *
 * @public
 */
declare interface ScanBindByShareQrcodeRsp {
    /**
     * 分享成功设备列表
     */
    iotIdList: string[];
    /**
     * 失败列表
     */
    failList?: ShareFailedDevice[];
}

/**
 * SD卡事件查询条件
 * @public
 */
declare type SDCardEventQueryReq = {
    /**
     * 产品型号
     */
    productKey: string;
    /**
     * 产品激活码
     */
    deviceName: string;
    /**
     * 查询开始时间。单位秒。
     */
    beginTime: number;
    /**
     * 查询结束时间。单位秒。
     */
    endTime: number;
    /**
     * 页码大小
     */
    pageSize: number;
    /**
     * 报警类型 不传默认全部
     */
    eventType?: EventTypeEnum;
};

/**
 * SD卡文件信息数据模型
 * @public
 */
declare type SDCardRecordFileInfo = {
    /**
     * 文件名称
     */
    filename: string;
    /**
     * 文件大小
     */
    fileSize: number;
    /**
     * 录制类型
     */
    recordType: number;
    /**
     * 录制开始时间
     */
    beginTime: number;
    /**
     * 录制结束时间
     */
    endTime: number;
};

/**
 * SD卡录制文件列表返回
 * @public
 */
declare type SDCardRecordFileQueryRsp = {
    /**
     * 云端录像文件列表
     */
    recordFileList: SDCardRecordFileInfo[];
    /**
     * 下一页是否有效
     */
    nextValid: boolean;
    /**
     * 下一页结束时间
     */
    nextEndTime?: number;
};

/**
 * SD卡录制统计查询条件
 * @public
 */
declare type SDCardRecordMonthQueryReq = {
    /**
     * 产品型号
     */
    productKey: string;
    /**
     * 产品激活码
     */
    deviceName: string;
    /**
     * 年份 例：2024
     */
    year: number;
    /**
     * 月份 1-12
     */
    month: number;
};

/**
 * SD卡查询条件
 * @public
 */
declare type SDCardRecordQueryReq = {
    /**
     * 产品型号
     */
    productKey: string;
    /**
     * 产品激活码
     */
    deviceName: string;
    /**
     * 查询开始时间
     */
    beginTime: number;
    /**
     * 查询结束时间。
     */
    endTime: number;
    /**
     * 页数
     */
    pageSize: number;
    /**
     * 录像类型：0 计划录像，1 报警录像，2 主动录像 99:所有类型
     */
    recordType?: number;
};

/**
 * 回看seek参数类型
 * @public
 */
declare enum SeekTypeEnum {
    /**
     * 普通
     */
    TYPE_NORMAL = 0,
    /**
     * SD卡回看按文件播放
     */
    TYPE_SDCARD_FILE = 1
}

/**
 * 服务协议
 * @public
 */
declare enum ServerSchemeEnum {
    HTTPS = "https",
    HTTP = "http",
    WSS = "wss",
    WS = "ws"
}

/**
 * 设置用户所在国家或区域
 * @param country - 国家或区域
 * @param regionId - 数据中心ID
 * @returns
 * @public
 */
declare function setCountry(country: Country, regionId?: number): Promise<void>;

/**
 * 设置设备昵称
 * @param iotId - 设备ID
 * @param nickname - 设备昵称
 * @public
 */
declare function setDeviceNickName(iotId: string, nickname: string): Promise<void>;

/**
 * 第三方自己管理设备关系，上层主动设置网关与子设备关联关系
 * @param gatewayDevice - 网关设备
 * @param childDeviceList - 子设备列表
 * @public
 */
declare function setGatewayDeviceRelevance(gatewayDevice: ISimpleDeviceInfo, childDeviceList: ISimpleDeviceInfo[]): void;

/**
 * 设置语言
 * @param locale - 语言
 * @returns
 * @public
 */
declare function setLocale(locale: LocaleEnum): Promise<void>;

/**
 * 设置用户token失效监听
 * @param onTokenInvalidListener - 监听回调
 * @public
 */
declare function setOnTokenInvalidListener(listener: OnTokenInvalidListener): void;

/**
 * 分享权限修改
 *
 * @param recordId - 分享记录ID
 * @param permissionList - 权限列表
 * @public
 */
declare function setSharePermission(recordId: number, permissionList: ShareDevicePermissionEnum[]): Promise<void>;

/**
 * 分享帐号类型
 * @public
 */
declare enum ShareAccountAttrTypeEnum {
    /**
     * 手机号
     */
    MOBILE = "MOBILE",
    /**
     * EMAIL
     */
    EMAIL = "EMAIL"
}

/**
 * 分享权限
 * @public
 */
declare enum ShareDevicePermissionEnum {
    /**
     * 直播
     */
    live = "live",
    /**
     * 设备控制
     */
    /**
     * 录像回看
     */
    record = "record",
    /**
     * 云台控制
     */
    ptz = "ptz",
    /**
     * 语音对讲
     */
    voiceIntercom = "voiceIntercom",
    /**
     * 高级设置
     */
    /**
     * 消息通知
     */
    notification = "notification"
}

/**
 * 设备分享给指定的用户
 *
 * @param shareDevicesReq - 分享给用户请求参数
 * @public
 */
declare function shareDevices(shareDevicesReq: ShareDevicesReq): Promise<ShareDevicesRsp>;

/**
 * 设备分享给指定的用户接口请求参数
 * @public
 */
declare interface ShareDevicesReq {
    /**
     * 要分享的设备列表。一次最多20
     */
    iotIdList: string[];
    /**
     * 目标用户唯一属性的类型。MOBILE（表示手机号）；EMAIL（表示邮箱）。
     */
    accountAttr: string;
    /**
     * 唯一标识目标用户的属性类型（如：手机号、邮箱等），手机号："MOBILE"，邮箱："EMAIL"。
     */
    accountAttrType: ShareAccountAttrTypeEnum;
    /**
     * 权限列表
     */
    permissionList: ShareDevicePermissionEnum[];
    /**
     * 手机号的区位码
     */
    mobileLocationCode?: string;
}

/**
 * 分享设备返回
 * @public
 */
declare interface ShareDevicesRsp {
    failList?: ShareFailedDevice[];
}

/**
 * 失败设备信息
 * @public
 */
declare interface ShareFailedDevice {
    /**
     * 设备ID
     */
    iotId: string;
    /**
     * 错误码
     */
    code: number;
    /**
     * 错误信息
     */
    message?: string;
}

/**
 * 信令地址信息
 * @internal
 */
declare class SignalAddressInfo {
    readonly proto: string;
    readonly ip: string;
    readonly port?: number;
    constructor(proto: string, ip: string, port?: number);
}

/**
 * 截图插件方法
 * @public
 */
declare enum SnapshotPluginMethodEnum {
    snapshot = "snapshot",
    snapshotZoom = "snapshotZoom"
}

/**
 * 码流类型
 * @public
 */
declare enum StreamTypeEnum {
    /**
     * 主码流
     */
    Main = 0,
    /**
     * 辅码流
     */
    Sub = 1
}

/**
 * 订阅事件类型
 * @public
 */
declare enum SubscribeEventTypeEnum {
    /**
     * 设备解绑
     */
    DEVICE_UNBIND = "DEVICE_UNBIND",
    /**
     * 设备状态
     */
    DEVICE_STATUS = "DEVICE_STATUS",
    /**
     * 设备物模型属性变化
     */
    DEVICE_THING_PROPERTIES_CHANGE = "DEVICE_THING_PROPERTIES_CHANGE",
    /**
     * 设备透传消息
     */
    DEV_TRANS_MSG = "DEV_TRANS_MSG"
}

/**
 * 对讲插件方法
 * @public
 */
declare enum TalkPluginMethodEnum {
    startTalk = "startTalk",
    stopTalk = "stopTalk"
}

/**
 * @public
 */
declare type ThingDataBase = {
    identifier: string;
    name: string;
};

/**
 * @public
 */
declare type ThingPropertyValue = {
    value?: string;
    time?: number;
    unit?: string;
};

/**
 * 设备SDK支持能力
 * @public
 */
declare enum ThingSDKAbilityEnum {
    /**
     * 支持 rtc-p2p
     */
    SDK_ABILITY_RTC_P2P = 1,
    /**
     * 支持rtc-cms
     */
    SDK_ABILITY_RTC_CMS = 2,
    /**
     * 支持rtmp推流
     */
    SDK_ABILITY_RTMP_PUSH = 3,
    /**
     * 支持直存
     */
    SDK_ABILITY_DIRECT_STORAGE = 4,
    /**
     * 录制计划
     *
     */
    SDK_ABILITY_SCHEDULE_RECORD = 5,
    /**
     * 关闭计划
     *
     */
    SDK_ABILITY_SCHEDULE_POWER_OFF = 6,
    /**
     * 支持接收和返回压缩数据
     */
    SDK_ABILITY_COMPRESS_DATA = 7,
    /**
     * 支持点云
     */
    SDK_ABILITY_SUPPORT_DIAN_YUN = 8,
    /**
     * 支持data channel通道
     */
    SDK_ABILITY_DATA_CHANNEL = 9,
    /**
     * RTC P2P支持发送音频数据
     */
    SDK_ABILITY_P2P_SEND_AUDIO = 10
}

/**
 * 物模型模板
 * @public
 */
declare type ThingTSL = {
    schema?: string;
    profile?: ThingTSLProfile;
    link?: string;
    services: ThingTSLService[];
    properties: ThingTSLProperty[];
    events?: ThingTSLEvent[];
    message?: string;
    localizedMsg?: string;
};

/**
 * @public
 */
declare type ThingTSLDataType = {
    specs: any;
    type: string;
};

/**
 * @public
 */
declare type ThingTSLEvent = ThingDataBase & {
    method: string;
    required?: boolean;
    type?: string;
    outputData?: ThingTSLServiceParam[];
};

/**
 * @public
 */
declare type ThingTSLProfile = {
    productKey: string;
    deviceName: string;
};

/**
 * @public
 */
declare type ThingTSLProperty = ThingDataBase & {
    accessMode: string;
    required: boolean;
    dataType: ThingTSLDataType;
};

/**
 * @public
 */
declare type ThingTSLService = ThingDataBase & {
    method: string;
    required: boolean;
    callType: string;
    outputData?: ThingTSLServiceParam[];
    inputData?: any;
};

/**
 * @public
 */
declare type ThingTSLServiceParam = ThingDataBase & {
    dataType: ThingTSLDataType;
};

/**
 * 事件信息
 * @public
 */
declare type TimelineEventInfo = {
    /**
     * 开始时间
     */
    beginTime: number;
    /**
     * 结束时间
     */
    endTime?: number;
    /**
     * 事件糊弄
     */
    eventType: EventTypeEnum;
    /**
     * 事件ID
     */
    eventId: number;
    /**
     * 事件缩略图
     */
    imgUrl?: string;
    /**
     * 图片ID
     */
    picId?: string;
    /**
     * 扩展数据
     */
    extraData?: string;
    region?: string;
    /**
     * 镜头ID
     */
    lensId?: number;
    /**
     * 数据类型 0：纯消息类型，1：录像类型，2：图片类型
     */
    dataType?: number;
    /**
     * 自定义事件的标识符
     *
     */
    identifier?: string;
};

/**
 * 录制信息数据模型
 * @public
 */
declare type TimelineRecordInfo = {
    /**
     * 开始时间
     */
    beginTime: number;
    /**
     * 结束时间
     */
    endTime: number;
    /**
     * 录制类型
     */
    recordType: number;
    /**
     * 设备机房
     */
    region?: string;
    /**
     * 流类型
     */
    streamType?: number;
};

/**
 * 无效状态异常
 * @public
 */
declare class TokenInvalidException extends RuntimeException {
    constructor(message: string);
    get name(): string;
}

/**
 * 解绑用户名下设备（取消被分享）
 * @param iotId - 设备ID
 * @public
 */
declare function unbindAccountAndDev(iotId: string): Promise<void>;

/**
 * 反初始化SDK
 * @public
 */
declare function uninit(): Promise<void>;

/**
 * 未知异常
 * @public
 */
declare class UnknownException extends RuntimeException {
    constructor(message: string);
    get name(): string;
}

/**
 * 能力不支持异常
 * @public
 */
declare class UnsupportFeatureException extends RuntimeException {
    constructor(message: string);
    get name(): string;
}

/**
 * 视频编码类型
 * @public
 */
declare enum VideoEncodeTypeEnum {
    NONE = "NONE",
    H264 = "H264",
    H265 = "H265",
    VP8 = "VP8",
    VP9 = "VP9",
    VP10 = "VP10",
    AV1 = "AV1"
}

/**
 * 视频元信息
 * @public
 */
declare type VideoMetaInfo = {
    codec: string;
    /**
     * 编码方式
     */
    codecType: VideoEncodeTypeEnum;
    codecWidth: number;
    codecHeight: number;
};

/**
 * 视频渲染器类型
 * @public
 */
declare type VideoRenderType = HTMLVideoElement | HTMLCanvasElement | null | undefined;

/**
 * 云回看播放地址请求
 * @public
 */
declare type VodUrlGetReq = {
    /**
     * 平台为设备颁发的ID，设备的唯一标识符。
     */
    iotId: string;
    /**
     * 查询开始时间。单位毫秒。
     */
    beginTime: number;
    /**
     * 查询结束时间。单位毫秒。
     */
    endTime: number;
    /**
     * 镜头ID，多目设备使用
     */
    lensId?: number;
};

/**
 * 云回看播放地址返回
 * @public
 */
declare type VodUrlRsp = {
    /**
     * 点播地址，带鉴权信息，无法重复使用
     */
    vodUrl: string;
};

/**
 * 缩放插件方法
 * @public
 */
declare enum ZoomPluginMethodEnum {
    setScale = "setScale",
    setRotate = "setRotate"
}

export { }
