import { AESDecryptRequestOptions } from '@polyv/request-plugin-aes-decrypt';
import { AESRequestOptions } from '@polyv/request-plugin-aes';
import { Ask } from '@polyv/chat-sdk';
import { AuthorizeAppSignRequestOptions } from '@polyv/request-plugin-authorize-app-sign';
import { AuthorizeTokenRequestOptions } from '@polyv/request-plugin-authorize-token';
import { ChannelProductPushingStatusInfo as ChannelProductPushingStatusInfo_2 } from '@polyv/product-sdk';
import { Chat } from '@polyv/chat-sdk';
import { ChatConfig } from '@polyv/chat-sdk';
import { ChatImage } from '@polyv/chat-image-upload-sdk';
import { ChatImageUpload } from '@polyv/chat-image-upload-sdk';
import Danmu from '@polyv/player-module/lib/danmu';
import { DanmuAddOptions } from '@polyv/player-module/lib/danmu';
import { EmotionParser } from '@polyv/emotion-sdk';
import { EventEmitter } from '@polyv/utils/es/event';
import { EventEmitter as EventEmitter_2 } from '@utils-ts/event';
import { GetAppSignFn } from '@polyv/request-plugin-authorize-app-sign';
import { GetOrderDetailParams } from '@polyv/interactions-receive-sdk/apps/order/type';
import { AddressManagement as IarAddressManagement } from '@polyv/interactions-receive-sdk';
import { Announcement as IarAnnouncement } from '@polyv/interactions-receive-sdk';
import { AnswerCard as IarAnswerCard } from '@polyv/interactions-receive-sdk';
import { CheckIn as IarCheckIn } from '@polyv/interactions-receive-sdk';
import { EnrollLottery as IarEnrollLottery } from '@polyv/interactions-receive-sdk';
import { FeedBack as IarFeedBack } from '@polyv/interactions-receive-sdk';
import { Lottery as IarLottery } from '@polyv/interactions-receive-sdk';
import { Order as IarOrder } from '@polyv/interactions-receive-sdk';
import { Product as IarProduct } from '@polyv/interactions-receive-sdk';
import { PushCard as IarPushCard } from '@polyv/interactions-receive-sdk';
import { QuestionAnswer as IarQuestionAnswer } from '@polyv/interactions-receive-sdk';
import { Questionnaire as IarQuestionnaire } from '@polyv/interactions-receive-sdk';
import { RedEnvelope as IarRedpack } from '@polyv/interactions-receive-sdk';
import { RedpackRain as IarRedpackRain } from '@polyv/interactions-receive-sdk';
import { RushAnswer as IarRushAnswer } from '@polyv/interactions-receive-sdk';
import { SeatTable as IarSeatTable } from '@polyv/interactions-receive-sdk';
import { Topic as IarTopicPK } from '@polyv/interactions-receive-sdk';
import { Tuwen as IarTuwen } from '@polyv/interactions-receive-sdk';
import { Vote as IarVote } from '@polyv/interactions-receive-sdk';
import { WelfareLottery as IarWelfareLottery } from '@polyv/interactions-receive-sdk';
import { IDirection } from '@polyv/player-module/lib/danmu';
import { Config as InteractionReceiveConfig } from '@polyv/interactions-receive-sdk/types';
import { IRequestOptions } from '@just4/request/types';
import { IXhrRequestResult } from '@just4/request/adapter/xhr';
import { LinkData } from '@polyv/utils/es/external-link';
import { LinkJumpWay } from '@polyv/utils/es/external-link';
import LiveLowLatencyPlayerModule from '@polyv/live-low-latency-player';
import { NormalProductData } from '@polyv/product-sdk';
import { OrderDetailData } from '@polyv/interactions-receive-sdk/apps/order/type';
import { PlaybackType as PlaybackType_2 } from '@polyv/white-board-sdk';
import PlayerMarquee from '@polyv/player-module/lib/marquee';
import PlayerWatermark from '@polyv/player-module/lib/watermark';
import { PlvSocket } from '@polyv/chat-sdk';
import { PlvSocketConfig } from '@polyv/chat-sdk';
import { Address as PolyvAddress } from '@polyv/product-sdk';
import * as PolyvBulletin from '@polyv/bulletin-sdk';
import { PolyvBusinessRequestPluginOptions } from '@polyv/request-plugin-polyv-business';
import * as PolyvChatPkgType from '@polyv/chat';
import { PolyvDomainInfo } from '@polyv/request-core';
import * as PolyvLuckyBag from '@polyv/lucky-bag-sdk';
import { Order as PolyvOrder } from '@polyv/product-sdk';
import { Payment as PolyvPayment } from '@polyv/product-sdk';
import { Product as PolyvProduct } from '@polyv/product-sdk';
import { PolyvRequest } from '@polyv/request-core';
import * as PolyvSocketPkgType from '@polyv/socket';
import * as PolyvVote from '@polyv/vote-sdk';
import { ProductConfig } from '@polyv/product-sdk';
import { ProjectName } from '@polyv/rtas-sdk';
import { RequestOptions } from '@polyv/request-core';
import { EventCata as RtasTrackEventCata } from '@polyv/rtas-sdk';
import { EventType as RtasTrackEventType } from '@polyv/rtas-sdk';
import { SignatureMethod } from '@polyv/request-plugin-authorize-app-sign';
import { SM2RequestOptions } from '@polyv/request-plugin-sm2';
import { StatusCodeRequestOptions } from '@polyv/request-plugin-status-code';
import { updateConfig } from '@polyv/interactions-receive-sdk';
import { updateRatsConfig } from '@polyv/interactions-receive-sdk';
import { WatchMobileUI } from '@polyv/white-board-ui/lib/watch-mobile';
import { WatchNormalUI } from '@polyv/white-board-ui/lib/watch-normal';
import * as WhiteBoardSdkTypes from '@polyv/white-board-sdk';

export declare interface AccountInfo {
    /** 账号 id */
    accountId: string;
    /** 公司名称 */
    companyName: string;
    /** 公司 logo */
    companyLogo: string;
    /** 是否被禁用 */
    isForbidden: boolean;
}

declare type AddPlaybackSubtitleOptionsType = ReplaySubtitleItem | playbackMultipleSubtitleOptions;

export declare enum AdvertHrefType {
    COMMON = "common",
    MULTI_PLATFORM = "multiplatform"
}

declare type AfterResponse<Options extends ApiOptions = ApiOptions> = (response: IXhrRequestResult, options: Options, url: string) => Promise<unknown>;

declare type AfterResponse_2<Options extends ApiOptions_2 = ApiOptions_2> = (response: IXhrRequestResult, options: Options, url: string) => Promise<unknown>;

declare enum AiAssistantAudioTaskResultStatus {
    Processing = "PROCESSING",
    Success = "SUCCESS",
    Fail = "FAIL",
    Timeout = "TIMEOUT"
}

/**
 * AI 助手模块事件
 * @version v0.10.0
 * @eventenum {@link AIAssistantEventsRelations}
 */
declare enum AIAssistantEvents {
    /**
     * AI 助手独立设置回调
     */
    AIAssistantChatSetupedIndependent = "AIAssistantChatSetupedIndependent",
    /**
     * AI 助手完整功能设置回调
     */
    AIAssistantChatSetupedComplete = "AIAssistantChatSetupedComplete",
    /**
     * AI 助手聊天状态变化
     */
    AIAssistantChatStatusChange = "AIAssistantChatStatusChange",
    /**
     * AI 助手聊天信息
     */
    AIAssistantChatMessage = "AIAssistantChatMessage",
    /**
     * 替换聊天消息事件
     */
    ReplaceAIAssistantChatMessage = "ReplaceAIAssistantChatMessage"
}

/**
 * AI 助手模块事件回调参数配置
 */
declare type AIAssistantEventsRelations = {
    [AIAssistantEvents.AIAssistantChatSetupedIndependent]: {};
    [AIAssistantEvents.AIAssistantChatStatusChange]: {
        /** 状态 */
        status: PolyvAIAssistantChatStatus;
    };
    [AIAssistantEvents.AIAssistantChatMessage]: {
        /** 聊天消息 */
        AIChatMsg: PolyvAIAssistantChatMsgType;
    };
    [AIAssistantEvents.ReplaceAIAssistantChatMessage]: {
        /** 需要替换的消息 Id */
        id: string;
        /** AI 助手聊天状态 */
        AIAssistantChatStatus: PolyvAIAssistantChatStatus;
        /** 聊天消息 */
        AIChatMsg: PolyvAIAssistantChatMsgType;
    };
};

declare interface AICoreConfig {
    /**
     * 语言类型
     */
    lang?: LangType;
    /**
     * 域名信息
     */
    domainInfo?: Partial<DomainInfo_3>;
    /**
     * 获取用户令牌信息
     */
    getViewerToken?: MaybePromise_3<ViewerTokenData_2>;
    /**
     * 获取聊天室服务令牌信息
     */
    getChatToken?: MaybePromise_3<ChatTokenData>;
    /**
     * 获取频道信息
     */
    getChannelInfo?: MaybePromise_3<ChannelInfo_2>;
    /**
     * 获取频道配置
     */
    getChannelConfig?: MaybePromise_3<ChannelConfig_3>;
    /**
     * 获取用户信息
     */
    getUserInfo?: MaybePromise_3<Partial<UserInfo_3>>;
    /**
     * 自动 setup
     * @default true
     */
    autoSetup?: boolean;
}

/**
 * 字幕行内容结构
 */
export declare interface AISubtitleParsedItem {
    /** 单位：毫秒 */
    start: number;
    /** 单位：毫秒 */
    end: number;
    text: string;
    index: string;
}

export declare interface AnchorChannelItem {
    /**
     * 频道号
     */
    channelId: string;
    /**
     * 频道名称
     */
    name: string;
    /**
     * 直播状态
     */
    liveStatus: LiveStatus;
    /**
     * 封面图
     */
    splashImg: string;
    /**
     * 封面图背景 id
     */
    splashImgBackgroundId: number;
    /**
     * 开始时间
     */
    startTime: number | null;
}

declare class AnswerCard extends InteractionBase_6 {
    AnswerCardType: typeof AnswerCardType;
    AnswerCardEvent: typeof AnswerCardEvent;
    AnswerCardSubmitResult: typeof AnswerCardSubmitResult;
    eventEmitter: EventEmitter<AnswerCardEventRelations, AnswerCardEvent>;
    private __currentAnswerCard?;
    constructor(interactionCore: InteractionCore);
    private __processSocketCache;
    private __onStartAnswerCard;
    private __onStopAnswerCard;
    private __onAnswerCardResult;
    /** 获取剩余的答题时间 */
    private __getDuration;
    private __pollingTimer?;
    /**
     * 开始轮询获取剩余答题时间
     */
    private __startPollingDuration;
    private __stopPollingDuration;
    /**
     * 获取当前用户作答
     * @param questionId 问题 id
     */
    private __getUserAnswer;
    /**
     * 获取当前答题卡数据
     */
    getCurrentAnswerCard(): AnswerCardData | undefined;
    private __saveAnswer;
    /**
     * 提交答题卡
     * @param options 提交答案数据
     * @returns 提交结果
     */
    submitAnswerCard(options: {
        answer: SubmitAnswerData;
    }): Promise<AnswerCardSubmitResult>;
}

/**
 * 答题卡数据
 */
declare interface AnswerCardData {
    /** 答题卡类型 */
    answerCardType: AnswerCardType;
    /** 答题卡限时时间 */
    duration?: number;
    /** 答题卡题目 */
    question: QuestionItem;
}

declare enum AnswerCardEvent {
    /**
     * 开始答题
     */
    StartAnswerCard = "StartAnswerCard",
    /**
     * 结束答题
     */
    StopAnswerCard = "StopAnswerCard",
    /**
     * 答题卡结果
     */
    AnswerCardResult = "AnswerCardResult",
    /**
     * 提交答题卡
     */
    SubmitAnswerCard = "SubmitAnswerCard"
}

declare type AnswerCardEventRelations = {
    [AnswerCardEvent.StartAnswerCard]: {
        /** 答题卡数据 */
        answerCardData: AnswerCardData;
    };
    [AnswerCardEvent.StopAnswerCard]: {
        /** 题目 id */
        questionId: string;
    };
    [AnswerCardEvent.AnswerCardResult]: {
        /** 答题卡结果 */
        answerCardResult: AnswerCardResult;
    };
};

/**
 * 答题卡结果
 */
declare interface AnswerCardResult {
    /** 答题卡数据 */
    answerCardData: AnswerCardData;
    /** 用户答案 */
    userAnswer?: QuestionAnswerType;
    /** 是否回答正确 */
    isRight: boolean;
    /** 是否有提交答案 */
    isSubmitted: boolean;
    /** 平均分，仅评分题返回 */
    averageScore?: number;
}

/**
 * 答题卡提交结果
 */
declare enum AnswerCardSubmitResult {
    /** 提交成功 */
    SubmitSuccess = "SubmitSuccess",
    /** 答题卡已结束，提交被忽略 */
    AnswerCardEnd = "AnswerCardEnd",
    /** 已提交过答案 */
    AnswerSubmitted = "AnswerSubmitted",
    /** 提交失败 */
    SubmitFailed = "SubmitFailed"
}

/**
 * 答题卡类型
 */
declare enum AnswerCardType {
    /**
     * 快速问答
     */
    Quick = "quick",
    /**
     * 题目
     */
    Question = "question"
}

/**
 * 答题抽奖条件
 */
declare interface AnswerCondition extends LotteryConditionBase<LotteryCondition.Answer> {
    /**
     * 答题方式
     */
    answerType: AnswerQuestionType;
    /**
     * 各奖品所需答对的数量
     */
    prizeLimit: number[];
    /**
     * 最小答题数量
     */
    minQuestionCount: number;
    /**
     * 问卷的题目总数
     */
    questionCount: number;
    /**
     * 已推送的题目数量
     */
    publishedCount: number;
    /**
     * 已回答数量
     */
    answeredCount: number;
    /**
     * 答对数量
     */
    rightCount: number;
    /**
     * 当前答题中的题目 id
     */
    currentQuestionId?: string;
    /**
     * 回答剩余时间
     */
    answerSurplusTime?: number;
    /**
     * 已推送的题目列表
     */
    questionList: AnswerQuestionItem[];
}

declare interface AnswerQuestionItem extends AnswerQuestionItemBasic {
    /** 答题时间，单位：毫秒 */
    time: number;
}

declare type AnswerQuestionItemBasic = Pick<QuestionItem<AnswerQuestionItemType>, 'questionId' | 'title' | 'type' | 'options' | 'required'>;

declare interface AnswerQuestionItemOption {
    /** 选项 id */
    key: string;
    /** 选项内容 */
    value: string;
}

declare type AnswerQuestionItemType = QuestionItemType.Radio | QuestionItemType.CheckBox | QuestionItemType.Judgement;

/**
 * 答题抽奖答题方式
 */
declare enum AnswerQuestionType {
    /**
     * 逐题推送
     */
    PushQuestion = "pushQuestion",
    /**
     * 整份推送
     */
    AutonomyAnswer = "autonomyAnswer"
}

declare interface AnswerResultData {
    /** 是否正确 */
    result: boolean;
    /** 当前题目回答人数 */
    answeredPeopleCount: number;
    /** 当前题目回答正确人数 */
    rightPeopleCount: number;
    /** 全部题目答题结果，仅在最后一题答题后返回 */
    allQuestionResult?: boolean[];
    /** 正确答案，仅在打错的时候返回 */
    rightAnswer?: string;
}

/** 音频模式，Y-音频模式，N-普通模式，V-VR 模式 */
export declare type ApiAudioModeType = 'Y' | 'N' | 'V';

declare class ApiError extends Error {
    code: number;
    data: unknown;
    constructor(options: ApiErrorOptions);
}

declare interface ApiErrorOptions {
    code: number;
    message: string;
    data?: unknown;
}

declare type ApiOptions = IRequestOptions;

declare type ApiOptions_2 = IRequestOptions;

/**
 * API 请求封装
 * @class
 */
declare class ApiQuery<Options extends ApiOptions = ApiOptions> {
    protected _identifyCore: IdentifyCore;
    /** 是否已被销毁（不再允许执行 ajax 调用） */
    private __isDestroyed;
    /** 请求域名前缀 */
    private __baseUrl;
    /** 超时数值 */
    private __timeout;
    /** 请求链接拦截器 */
    private __interceptRequestUrl?;
    /** 请求处理器 */
    private __beforeRequest?;
    /** 响应处理器 */
    private __afterResponse?;
    constructor(options: ApiQueryConfig);
    /**
     * 设置请求链接拦截器
     * @param interceptRequestUrl 请求链接拦截器
     */
    protected _setInterceptRequestUrl(interceptRequestUrl: InterceptRequestUrl<Options>): void;
    /**
     * 设置请求处理器
     * @param beforeRequest 请求处理器
     */
    protected _setBeforeRequest(beforeRequest: BeforeRequest<Options>): void;
    /**
     * 设置响应处理器
     * @param afterResponse 响应处理器
     */
    protected _setAfterResponse(afterResponse: AfterResponse<Options>): void;
    /**
     * 修改请求前缀
     * @param baseUrl 新的请求前缀
     * @returns this
     */
    setBaseUrl(baseUrl: string | ApiQueryBaseUrlFn): this;
    /**
     * 获取请求地址前缀
     */
    getBaseUrl(): string;
    /** 生成请求地址，插入 baseUrl */
    generateUrl(url: string): string;
    /** 发起请求 */
    protected _request<R = unknown>(url: string, options: Options): Promise<R>;
    /**
     * 过滤请求中的 params 和 data，将 undefined 的字段移除
     * @param target 目标对象
     */
    private __filterParamsData;
    /** 发起 get 请求 */
    get<R = unknown, P = object>(url: string, params: P, options?: Options): Promise<R>;
    /** 发起 post 请求 */
    post<R = unknown, D = object>(url: string, data: D, options?: Options): Promise<R>;
    destroy(): void;
}

/**
 * API 请求封装
 * @class
 */
declare class ApiQuery_2<Options extends ApiOptions_2 = ApiOptions_2> {
    protected _watchCore: PolyvWatchCore;
    /** 是否已被销毁（不再允许执行 ajax 调用） */
    private __isDestroyed;
    /** 请求域名前缀 */
    private __baseUrl;
    /** 超时数值 */
    private __timeout;
    /** 请求链接拦截器 */
    private __interceptRequestUrl?;
    /** 请求处理器 */
    private __beforeRequest?;
    /** 响应处理器 */
    private __afterResponse?;
    constructor(options: ApiQueryConfig_2);
    /**
     * 设置请求链接拦截器
     * @param interceptRequestUrl 请求链接拦截器
     */
    protected _setInterceptRequestUrl(interceptRequestUrl: InterceptRequestUrl_2<Options>): void;
    /**
     * 设置请求处理器
     * @param beforeRequest 请求处理器
     */
    protected _setBeforeRequest(beforeRequest: BeforeRequest_2<Options>): void;
    /**
     * 设置响应处理器
     * @param afterResponse 响应处理器
     */
    protected _setAfterResponse(afterResponse: AfterResponse_2<Options>): void;
    /**
     * 修改请求前缀
     * @param baseUrl 新的请求前缀
     * @returns this
     */
    setBaseUrl(baseUrl: string | ApiQueryBaseUrlFn_2): this;
    /**
     * 获取请求地址前缀
     */
    getBaseUrl(): string;
    /** 生成请求地址，插入 baseUrl */
    generateUrl(url: string): string;
    /** 发起请求 */
    protected _request<R = unknown>(url: string, options: Options): Promise<R>;
    /**
     * 过滤请求中的 params 和 data，将 undefined 的字段移除
     * @param target 目标对象
     */
    private __filterParamsData;
    /** 发起 get 请求 */
    get<R = unknown, P = object>(url: string, params: P, options?: Options): Promise<R>;
    /** 发起 post 请求 */
    post<R = unknown, D = object>(url: string, data: D, options?: Options): Promise<R>;
    destroy(): void;
}

declare interface ApiQueryBaseUrlFn {
    (): string;
}

declare interface ApiQueryBaseUrlFn_2 {
    (): string;
}

/** ajax 请求库构造函数参数 */
declare interface ApiQueryConfig {
    identifyCore: IdentifyCore;
    /** 请求前缀 */
    baseUrl: string | ApiQueryBaseUrlFn;
    /** 超时数值 */
    timeout?: number;
}

/** ajax 请求库构造函数参数 */
declare interface ApiQueryConfig_2 {
    watchCore: PolyvWatchCore;
    /** 请求前缀 */
    baseUrl: string | ApiQueryBaseUrlFn_2;
    /** 超时数值 */
    timeout?: number;
}

/**
 * createWatchCore 参数类型
 * @desc 核心类依赖外部应用的配置
 */
export declare type AppConfig = AppConfigForSDK & AppConfigForBasicBusiness & AppConfigForViewer & AppConfigForAuth & AppConfigForPlay & getExtBusinessPropType;

declare interface AppConfigForAuth {
    /** 自动授权参数 */
    autoAuthParams?: {
        /** 验证码 */
        code?: string;
        /**
         * 忽略微信授权，默认关
         * @version v0.6.0
         * */
        ignoreWxAuth?: YN;
        /**
         * 微信快照页模式，默认关
         * @desc 保利威微信回调时入参
         * @version v0.6.0
         * */
        wxSnapshotPageMode?: YN;
        /**
         * 强制优先独立授权，默认关
         * @desc 当配置自定义授权和独立授权冲突时，优先用独立授权
         * @version v2.1.0
         */
        forceDirectAuth?: YN;
        /**
         * 忽略用户系统，默认关
         * @version v2.2.0
         */
        ignoreWatchUserSystem?: YN;
    };
    /**
     * 一客一码邀请参数
     * @version v0.12.0
     */
    saleInviteParams?: {
        saleCode?: string;
        /** 一客一码--销售邀请的客户id */
        inviteCustomerId?: string;
    };
}

declare interface AppConfigForBasicBusiness {
    /** 频道号 */
    channelId: string;
    /**
     * 目标场次 Id
     * @desc 指定场次
     * @version v2.4.0
     */
    targetSessionId?: string;
    /** 渠道 id */
    promoteId?: string;
    /** 测试模式 token */
    testModeToken?: string;
    /** 网络类型 */
    zone?: ZoneType;
}

declare interface AppConfigForPlay {
    /** 回放 vid */
    vid?: string;
    /** 回放类型 */
    playbackOrigin?: PlaybackOrigin | PlaybackType_2;
    /**
     * 是否使用 ip 地址进行 CDN 拉流，仅支持 PC 端
     * @version v0.5.0
     * */
    ipPlay?: boolean;
}

declare interface AppConfigForSDK {
    /**
     * SDK 唯一Id，在创建多实例时必传
     * @version v2.0.0
     */
    uniqueId?: string;
    /**
     * 使用共享的 token
     * @default true
     * @version v2.0.0
     */
    useShareAuthToken?: boolean;
    /** SDK 需要加载的环境 */
    env?: SdkLoaderEnv;
    /** 语言类型 */
    language?: LanguageType;
    /** 自定义域名 */
    domainInfo?: Partial<DomainInfo>;
    /**
     * 集成 SDK 脚本地址配置
     * @warn 会直接忽视 env 配置，覆盖默认的集成 SDK 脚本地址
     * */
    sdkIntegration?: SdkIntegrationConfig;
}

declare interface AppConfigForViewer {
    /**
     * 观众信息
     */
    userInfo?: UserInfo;
    /**
     * 邀请信息
     */
    inviteInfo?: {
        /** 邀请海报唯一ID */
        invitePosterId?: string;
        /** 企业微信分享海报的企微员工 ID */
        wxInviteId?: string;
        /** 受邀者 ID */
        invitee?: string;
    };
    /**
     * 统计信息
     */
    statisticsParams?: StatisticsParams;
}

/**
 * 申请提现失败原因
 */
export declare enum ApplyWithdrawFailReason {
    /** 未知 */
    Unknown = "Unknown",
    /** 提现金额超过用户余额 */
    AmountOverLimit = "AmountOverLimit",
    /** 无效的提现金额，必须大于 1 元 */
    InvalidAmount = "InvalidAmount",
    /** 申请失败 */
    ApplyFail = "ApplyFail",
    /** 需要在微信端打开 */
    NeedWechat = "NeedWechat"
}

/**
 * 提交提现申请参数
 */
export declare interface ApplyWithdrawParams {
    /** 提现金额，单位：元 */
    amount: number;
}

/**
 * 申请提现结果
 */
export declare type ApplyWithdrawResult = CommonResult<ApplyWithdrawFailReason, {
    signData?: WxMerchantTransferSignData;
}>;

declare interface AppSignSecretKey {
    /**
     * 应用 id
     */
    appId: string;
    /**
     * 应用密钥
     */
    appSecret: string;
}

declare interface AskApiMsgType {
    /** 内容 */
    content: string;
    /** 消息标识 */
    id?: string;
    /** 时间 */
    time?: number;
    /** 消息类型 */
    msgType: '' | 'image';
    /** 讲师回答的学生 id */
    s_userId?: string;
    /** 用户信息 */
    user: ChatMessageUser;
    /** 状态 */
    status?: 'error';
    /** 消息 */
    message?: string;
    /** 违规词内容 */
    value?: string;
}

/**
 * 提问事件
 */
export declare enum AskEvents {
    /** 学生提问事件 */
    StudentQuestion = "StudentQuestion",
    /** 老师回答事件 */
    TeacherAnswer = "TeacherAnswer",
    /**
     * 系统消息
     * @version v0.5.1
     * */
    SystemMessage = "SystemMessage",
    /**
     * 提问触发严禁词
     * @version v0.9.0
     */
    SendBadWord = "SendBadWord",
    /**
     * 替换提问消息事件
     * @version v1.3.0
     */
    ReplaceAskMessage = "ReplaceAskMessage",
    /**
     * 删除提问消息事件
     * @version v1.3.0
     */
    RemoveAskMessage = "RemoveAskMessage",
    /**
     * 删除单条提问消息事件
     * @version v2.14.0
     */
    RemoveSingleQuestion = "RemoveSingleQuestion",
    /**
     * 删除提问用户
     * @version v2.14.0
     */
    RemoveAskUser = "RemoveAskUser"
}

export declare type AskEventsRelations = {
    [AskEvents.StudentQuestion]: {
        askMsg: AskMsgType;
    };
    [AskEvents.TeacherAnswer]: {
        askMsg: AskMsgType;
    };
    [AskEvents.SystemMessage]: {
        askMsg: AskMsgType;
    };
    [AskEvents.SendBadWord]: {
        word: string;
    };
    [AskEvents.ReplaceAskMessage]: {
        /**
         * 替换的消息 id
         */
        id: string;
        askMsg: AskMsgType;
    };
    [AskEvents.RemoveAskMessage]: {
        id?: string;
        askMsg?: AskMsgType;
    };
    [AskEvents.RemoveSingleQuestion]: {
        id: string;
    };
    [AskEvents.RemoveAskUser]: {
        userId: string;
    };
};

export declare type AskHistoryResultNew = PageContent<AskMsgType>;

/**
 * 提问消息类型
 */
export declare type AskMsgType = (ChatMsgSpeakType | ChatMsgImageType | ChatMsgSystemType) & {
    user?: ChatMessageUser<ChatUserType>;
    isLocal?: boolean;
};

/** 提问设置 */
export declare interface AskSetting {
    /** 提问发送图片开关 */
    questionImageEnabled: boolean;
}

/**
 * 登记观看的表单选项
 */
export declare interface AuthInfoItem {
    /** 表单类型 */
    type: AuthInfoType;
    /** 信息标题 */
    name: string;
    /** 信息描述 */
    placeholder: string;
    /** 是否需要短信验证 */
    sms?: YN;
    /** 下拉选项列表，用英文逗号隔开 */
    options?: string;
    /** 是否必填 */
    required: YN;
}

/**
 * 登记观看 propValue key 类型
 */
export declare type AuthInfoPropValKey = `propValue${number}`;

/**
 * 登记观看 propValue 类型
 */
export declare type AuthInfoPropValType = Record<AuthInfoPropValKey, string>;

/**
 * 登记观看的选项类型
 */
export declare enum AuthInfoType {
    /** 姓名 */
    Name = "name",
    /** 文本 */
    Text = "text",
    /** 手机号码 */
    Mobile = "mobile",
    /** 下拉选项 */
    Option = "option",
    /** 数值 */
    Number = "number"
}

/**
 * 支付信息数据
 */
export declare interface AuthPayData {
    /**
     * 支付二维码图片地址
     */
    qrcodeUrl: string;
    /**
     * 支付地址
     */
    codeUrl: string;
    /**
     * 支付 id
     */
    payId: string;
    /**
     * 微信支付签名数据，仅微信环境下返回
     */
    wxPaySignData?: WxPaySignData;
}

/**
 * 付费观看错误原因
 */
export declare enum AuthPayFailReason {
    /** 未知 */
    Unknown = "Unknown",
    /** 不允许 */
    NotAllow = "NotAllow"
}

/** 观看条件隐私声明信息 */
export declare interface AuthPrivacyInfo {
    /** 隐私声明内容 */
    privacyContent: string;
    /** 是否开启隐私声明 */
    privacyStatus: YN;
}

/** 观看条件信息 */
export declare type AuthSettingItem = AuthSettingItemMaps[keyof AuthSettingItemMaps];

/**
 * 验证码观看条件设置信息
 */
export declare interface AuthSettingItemCode extends AuthSettingItemCommon<AuthType.Code>, AuthPrivacyInfo {
    /** 欢迎标题 */
    codeAuthTips: string;
    /** 入口文本 */
    codeEntryText: string | null;
    /** 二维码图片地址 */
    qcodeImg: string;
    /** 二维码提示文案 */
    qcodeTips: string;
}

/** 观看条件信息公用类型 */
export declare interface AuthSettingItemCommon<T extends AuthType> {
    /** 条件类型 */
    authType: T;
    /** 是否启用 */
    enabled: YN | null;
}

/**
 * 自定义授权设置信息
 *
 * 关于自定义授权设置及服务端的处理流程可见帮助中心文档：[自定义授权](https://help.polyv.net/index.html#/live/api/web/watch_condition/customauth_2)
 */
export declare interface AuthSettingItemCustom extends AuthSettingItemCommon<AuthType.Custom> {
    /** 自定义 url */
    customUri: string;
    /** 入口文本 */
    customEntryText: string | null;
}

/**
 * 独立授权设置信息
 *
 * 关于独立授权设置及服务端的处理流程可见帮助中心文档：[独立授权](https://help.polyv.net/index.html#/live/api/web/watch_condition/direct_auth)
 */
export declare interface AuthSettingItemDirect extends AuthSettingItemCommon<AuthType.Direct> {
    /** 授权失败重定向 url */
    directRedirectUri?: string;
}

/**
 * 企业微信授权设置信息
 */
export declare interface AuthSettingItemEnterpriseWeChat extends AuthSettingItemCommon<AuthType.EnterpriseWeChat> {
}

/**
 * 外部授权设置信息
 *
 * 关于外部授权设置及服务端的处理流程可见帮助中心文档：[外部授权](https://help.polyv.net/index.html#/live/api/web/watch_condition/external_authorization_2)
 */
export declare interface AuthSettingItemExternal extends AuthSettingItemCommon<AuthType.External> {
    /** 授权 url */
    externalUri: string;
    /** 授权失败重定向 url */
    externalRedirectUri: string;
    /** 入口文本 */
    externalEntryText: string | null;
    /** 入口登录按钮是否启用，默认为 Y */
    externalButtonEnabled: YN | null;
}

/**
 * 登记观看条件设置信息
 */
export declare interface AuthSettingItemInfo extends AuthSettingItemCommon<AuthType.Info>, AuthPrivacyInfo {
    /** 欢迎标题 */
    infoAuthTips: string;
    /** 提示信息 */
    infoDesc: string;
    /** 入口文本 */
    infoEntryText: string | null;
}

/**
 * 邀请观看观看设置信息
 */
export declare interface AuthSettingItemInviteWatch extends AuthSettingItemCommon<AuthType.InviteWatch> {
}

export declare type AuthSettingItemMaps = {
    [AuthType.None]: AuthSettingItemNone;
    [AuthType.Pay]: AuthSettingItemPay;
    [AuthType.Phone]: AuthSettingItemPhone;
    [AuthType.Info]: AuthSettingItemInfo;
    [AuthType.Code]: AuthSettingItemCode;
    [AuthType.Custom]: AuthSettingItemCustom;
    [AuthType.External]: AuthSettingItemExternal;
    [AuthType.Direct]: AuthSettingItemDirect;
    [AuthType.EnterpriseWeChat]: AuthSettingItemEnterpriseWeChat;
    [AuthType.SaleShare]: AuthSettingItemSaleShare;
    [AuthType.InviteWatch]: AuthSettingItemInviteWatch;
};

/**
 * 无条件观看/公开观看设置信息
 */
export declare interface AuthSettingItemNone extends AuthSettingItemCommon<AuthType.None> {
}

/**
 * 付费观看条件设置信息
 */
export declare interface AuthSettingItemPay extends AuthSettingItemCommon<AuthType.Pay> {
    /** 欢迎标题 */
    payAuthTips: string;
    /** 观看价格 */
    price: number;
    /** 入口文本 */
    payEntryText: string | null;
    /** 试看开关 */
    trialWatchEnabled: YN;
    /** 试看时长，单位：分钟 */
    trialWatchTime: number;
}

/**
 * 白名单观看条件设置信息
 */
export declare interface AuthSettingItemPhone extends AuthSettingItemCommon<AuthType.Phone>, AuthPrivacyInfo {
    /** 欢迎标题 */
    authTips: string;
    /** 入口文本 */
    whiteListEntryText: string | null;
    /** 输入提示 */
    whiteListInputTips: string;
}

/**
 * 一客一码观看设置信息
 */
export declare interface AuthSettingItemSaleShare extends AuthSettingItemCommon<AuthType.SaleShare> {
}

/**
 * 观看条件类型
 */
export declare enum AuthType {
    /**
     * 无条件观看/公开观看
     * @setting {@link AuthSettingItemNone}
     */
    None = "none",
    /**
     * 付费观看
     * @setting {@link AuthSettingItemPay}
     */
    Pay = "pay",
    /**
     * 白名单观看
     * @setting {@link AuthSettingItemPhone}
     */
    Phone = "phone",
    /**
     * 登记观看
     * @setting {@link AuthSettingItemInfo}
     */
    Info = "info",
    /**
     * 验证码观看
     * @setting {@link AuthSettingItemCode}
     */
    Code = "code",
    /**
     * 自定义授权
     * @setting {@link AuthSettingItemCustom}
     */
    Custom = "custom",
    /**
     * 外部授权
     * @setting {@link AuthSettingItemExternal}
     */
    External = "external",
    /**
     * 独立授权
     * @setting {@link AuthSettingItemDirect}
     */
    Direct = "direct",
    /**
     * 企业微信授权
     * @setting {@link AuthSettingItemEnterpriseWeChat}
     */
    EnterpriseWeChat = "enterpriseWeChat",
    /**
     * 一客一码授权
     * @internal
     * @ignore
     * @warn 一客一码并不会当作观看条件使用，而是通过另外的授权方式，授权方式请参考 `watchCore.saleInvite` 模块
     * @setting {@link AuthSettingItemSaleShare}
     */
    SaleShare = "saleShare",
    /**
     * 邀请观看
     * @setting {@link AuthSettingItemInviteWatch}
     */
    InviteWatch = "inviteWatch"
}

/**
 * 观看条件验证失败原因
 */
export declare enum AuthVerifyError {
    /**
     * 未知错误
     * @scene 通用
     */
    Unknown = "Unknown",
    /**
     * 需要重定向
     * @scene 通用
     */
    RedirectUrl = "RedirectUrl",
    /**
     * 图形验证码错误
     * @scene 通用
     * @version v2.4.0
     */
    ImageCodeError = "ImageCodeError",
    /**
     * 系统异常
     * @scene 通用
     * @version v1.3.0
     */
    SystemException = "SystemException",
    /**
     * 非法观看条件
     * @scene 通用
     * @version v1.3.0
     */
    InvalidWatchAuth = "InvalidWatchAuth",
    /**
     * 白名单会员码为空
     * @scene 白名单观看
     */
    PhoneEmpty = "PhoneEmpty",
    /**
     * 白名单会员码已使用
     * @scene 白名单观看
     * @version v1.5.0
     */
    PhoneUsed = "PhoneUsed",
    /**
     * 白名单会员码不存在
     * @scene 白名单观看
     */
    PhoneNotExist = "PhoneNotExist",
    /**
     * 短信验证码错误
     * @scene 登记观看
     */
    SmsCodeError = "SmsCodeError",
    /**
     * 手机号未登记
     * @scene 登记观看
     */
    PhoneNotRegister = "PhoneNotRegister",
    /**
     * 观看验证码为空
     * @scene 验证码观看
     */
    CodeEmpty = "CodeEmpty",
    /**
     * 观看验证码错误
     * @scene 验证码观看
     */
    CodeError = "CodeError",
    /**
     * 观看验证码需要验证
     * @scene 验证码观看
     * @version v2.4.0
     */
    CodeNeedVerify = "CodeNeedVerify",
    /**
     * 缺少自定义授权参数
     * @scene 自定义授权
     */
    CustomSignParamsMiss = "CustomSignParamsMiss",
    /**
     * 外部授权失败
     * @scene 外部授权
     */
    ExternalError = "ExternalError",
    /**
     * 同个观众
     * @scene 独立授权/外部授权
     * @version v1.6.0
     */
    SameViewer = "SameViewer"
}

/**
 * 观看条件验证结果
 */
export declare type AuthVerifyResult<T extends AuthType> = AuthVerifyResultSuccess<T> | AuthVerifyResultFail<T>;

/**
 * 观看条件验证结果（失败）
 */
export declare interface AuthVerifyResultFail<T extends AuthType = AuthType> {
    /** 观看条件类型 */
    authType: T;
    /** 成功状态 */
    success: false;
    /** 失败原因 */
    failReason: AuthVerifyError;
    /** 失败信息 */
    failMessage?: string;
    /** 获取重定向跳转地址 */
    getRedirectUrl?: () => string;
}

/**
 * 观看条件验证结果（成功）
 */
export declare interface AuthVerifyResultSuccess<T extends AuthType = AuthType> {
    /** 观看条件类型 */
    authType: T;
    /** 成功状态 */
    success: true;
}

/**
 * 微信扫码观看信息
 */
export declare interface AuthWechatPayCheckData {
    /**
     * 记录 id
     */
    logId: string;
    /**
     * 微信二维码内容
     */
    codeUrl: string;
    /**
     * 二维码图片地址
     */
    qrcodeUrl: string;
}

/**
 * 背景类型
 */
export declare enum BackgroundType {
    /**
     * 直播截图
     */
    LiveScreenshot = "liveScreenshot",
    /**
     * 系统默认
     */
    SystemDefault = "systemDefault",
    /**
     * 自定义
     */
    Custom = "custom"
}

/** 后台支持配置的字幕语种 */
declare type BackstageSubtitleLanguage = 'Chinese' | 'English' | 'Tagalog' | 'Thai' | 'Malay' | 'Indonesian' | 'Lao' | 'Burmese' | 'Vietnamese' | 'French' | 'Japanese' | 'German' | 'Korean' | 'Russian' | 'Portuguese' | 'Turkish' | 'Arabic' | 'Spanish' | 'Khmer' | 'Tamil';

export declare interface BarrageAddCallback {
    (data: BarrageAddCallbackData): void;
}

export declare interface BarrageAddCallbackData extends BarrageChatMsgEvtResult {
    msg: string;
    user: ChatMessageUser;
    isSelf: boolean;
}

/**
 * 弹幕添加拦截器
 */
export declare interface BarrageAddIntercept {
    (data: BarrageAddCallbackData): boolean;
}

/**
 * 弹幕参数
 */
export declare interface BarrageAddOptions {
    /**
     * 弹幕文本，支持双中括号内嵌图片
     */
    msg: string;
    /**
     * 弹幕文本字体颜色
     * @default #fff
     */
    fontColor?: string;
    /**
     * 弹幕文本字号
     * @default 24
     */
    fontSize?: number;
    /**
     * 该条弹幕文本是否自己发送的
     */
    self?: boolean;
    /**
     * 本人发送的弹幕消息边框颜色, 不设置则不显示边框
     */
    selfBorderColor?: string;
}

export declare type BarrageChatMsgEvtResult = ChatEventsRelations[ChatEvents.ChatMessage];

/**
 * 弹幕设置映射关系
 * @desc 参数值可以是长度为1或2的数组。长度为2时分别代表PC\H5端档位值, 长度为1时统一代表PC\H5端档位值。
 */
export declare interface BarrageGearValue {
    /** 弹幕速度与档位的映射关系 */
    speed?: UniversalParams<string>[];
    /** 弹幕字号与档位的映射关系 */
    size?: UniversalParams<string>[];
}

/**
 * 弹幕位置信息
 */
export declare interface BarrageLocationInfo {
    /** 弹幕位置类型 */
    type: LocationType;
    /** 弹幕位置类型ID */
    index: number;
    /** 弹幕位置类型对应方向 */
    direction: IDirection;
    /** 弹幕位置类型对应显示百分比 */
    percent: number;
}

/**
 * 弹幕设置
 */
export declare interface BarrageSetting {
    /**
     * 弹幕功能开关
     */
    barrageEnabled: boolean;
    /**
     * 弹幕默认显示状态
     */
    barrageDefaultShow: boolean;
    /**
     * 弹幕速度
     */
    barrageSpeed: number;
    /**
     * 弹幕速度档位
     */
    barrageSpeedDefaultGrade: number;
    /**
     * 弹幕字号
     */
    barrageSize: number;
    /**
     * 弹幕字号档位
     */
    barrageSizeDefaultGrade: number;
    /**
     * 弹幕透明度
     */
    barrageAlpha: number;
    /**
     * 弹幕默认透明度
     */
    barrageDefaultAlpha: number;
    /**
     * 弹幕位置ID
     */
    barrageLocationDefaultId: number;
}

/**
 * 弹幕对象
 */
export declare interface BarrageTarget {
    /** 弹幕对象标识 */
    id: string;
    /** 弹幕实例 */
    barrageInstance: Danmu;
    /** 添加弹幕 */
    add: (options: BarrageAddOptions) => void;
    /** 显示弹幕 */
    show: () => void;
    /** 隐藏弹幕 */
    hide: () => void;
    /** 清空弹幕 */
    clear: () => void;
    /** 重置尺寸 */
    resize: () => void;
    /** 切换弹幕速度 */
    changeSpeed: (speed: number) => void;
    /** 切换弹幕字号 */
    changeSize: (size: number) => void;
    /** 切换弹幕显示方向 */
    changeAreaDirection: (direction: IDirection) => void;
    /** 切换弹幕显示百分比 */
    changeAreaPercentage: (percent: number) => void;
    /** 切换弹幕位置 */
    changeLocation: (index: number) => void;
    /** 切换弹幕透明度 */
    changeAlpha: (alpha: number) => void;
    /** 处理弹幕事件 */
    onBarrageAddEvent: BarrageAddCallback;
    /** 销毁当前对象 */
    destroyTarget: () => void;
    /** 比较容器大小 */
    compareContainerSize: () => void;
}

declare class BasicApiRequest extends PolyvRequest {
}

declare type BeforeRequest<Options extends ApiOptions = ApiOptions> = (options: Options) => Promise<Options>;

declare type BeforeRequest_2<Options extends ApiOptions_2 = ApiOptions_2> = (options: Options) => Promise<Options>;

export declare interface BindIdentityInfoParams {
    /**
     * 手机号
     */
    phoneNumber?: string;
    /**
     * 手机区号
     */
    areaCode?: string;
    /**
     * 短信验证码
     */
    smsCode?: string;
}

/**
 * 取消自定义直播预约入参
 */
export declare interface CancelCustomLiveBookingOptions {
    /** 频道 id */
    otherChannelId?: string;
}

/**
 * 取消短信直播预约入参
 */
export declare interface CancelSmsLiveBookingOptions {
    /** 手机号 */
    phoneNumber: string;
    /** 区号 */
    areaCode: string;
    /** 频道 id */
    otherChannelId?: string;
}

/**
 * 取消提现参数
 */
export declare interface CancelWithdrawParams {
    /** 提现单号 */
    outBillNo: string;
    /** 提现 id */
    withdrawId: string;
}

/**
 * 取消微信预约入参
 * @deprecated 请使用 WxLiveBookingOptions
 */
export declare interface CancelWxLiveBookingOptions {
    /** 频道 id */
    otherChannelId?: string;
}

declare interface ChangeVidParams {
    vid: string;
    autoplay?: boolean;
    statistics?: VodPlayerStatistics;
    ts?: number;
    sign?: string;
    playsafe?: string;
}

declare interface Channel {
    /** 频道 ID */
    channelId: string;
    /** 频道名称 */
    name: string;
}

/**
 * 频道页面广告设置
 */
export declare interface ChannelAdvertSetting {
    /** 页面广告开关 */
    pageAdvertEnabled: boolean;
    /** 允许关闭页面广告 */
    closeAdvertEnabled: boolean;
    /** 页面广告列表 */
    pageAdvertList: PageAdvertItem[];
}

export declare type ChannelAgreementConfig = {
    [key in LanguageType]: {
        /** 内容 */
        content: string;
        /** 弹窗标题 */
        dialogTitle: string;
        /** 弹窗内容 */
        dialogContent: string;
    };
};

/**
 * 频道协议配置
 */
export declare interface ChannelAgreementData {
    /** 弹窗标题 */
    title: string;
    /** 弹窗标题(英文) */
    titleEn: string;
    /** 弹窗内容 */
    content: string;
    /** 弹窗内容(英文) */
    contentEn: string;
    /** 内容 */
    contentTip: string;
    /** 内容(英文) */
    contentTipEn: string;
}

/**
 * AI 相关频道配置
 */
export declare interface ChannelAIConfig {
    /** AI 助手开关，默认关 */
    aiAssistantEnabled: YN;
    /** AI 助手Id */
    aiAssistantId: number | null;
    /** AI 助手名称 */
    aiAssistantName: string | null;
    /** AI 助手编码 */
    aiAssistantCode: string | null;
}

export declare interface ChannelAnchorInfo {
    /**
     * 主讲 id
     */
    anchorId: number;
    /**
     * 主讲头衔
     */
    actor: string;
    /**
     * 主讲昵称
     */
    nickname: string;
    /**
     * 主讲头像
     */
    avatar: string;
    /**
     * 描述
     */
    description: string;
    /**
     * 性别
     */
    sex: 'U' | 'M' | 'W';
}

/** 音频模式 */
export declare enum ChannelAudioMode {
    /** 特殊直播音频模式 */
    CustomLiveAudio = "CustomLiveAudio",
    /** 正常音视频模式 */
    NormalAudio = "NormalAudio",
    /** 纯音频模式 */
    OnlyAudio = "OnlyAudio",
    /** VR 音频模式 */
    VrAudio = "VrAudio"
}

/** 观看条件设置 */
export declare interface ChannelAuthSetting {
    /** 登记观看的登记表设置列表 */
    authInfoFields?: AuthInfoItem[];
    /** 观看条件列表 */
    authSettings: AuthSettingItem[];
    /** 强制微信授权，默认关 */
    forceWxAuth: YN;
    /** 强制微信授权持久化(长时间授权态)，默认关 */
    wxPersistentAuthEnabled: YN;
}

export declare interface ChannelBasicDetailOptions {
    language: string;
}

export declare interface ChannelBasicDetailRequestParams {
    channelId: string;
    language: string;
}

/** 频道基础信息 */
export declare interface ChannelBasicInfo {
    /** 频道标题 */
    title: string;
    /** 频道主持人 */
    publisher: string;
    /** 频道描述 */
    description: string;
}

/**
 * 频道设置
 */
export declare type ChannelConfig = ChannelDetail['channelConfig'];

/**
 * 频道配置
 */
declare interface ChannelConfig_2 {
    /**
     * 埋点上报总开关
     */
    watchEventTrackEnabled?: boolean;
    /**
     * 互动事件上报开关
     */
    productTrackEnabled?: boolean;
    /**
     * 新场次开关
     */
    newSessionEnabled?: boolean;
    /**
     * 当前推送的商品信息
     */
    channelProductPushingStatusVO?: ChannelProductPushingStatusInfo;
    /**
     * 商品讲解开关
     */
    productExplainEnabled?: boolean;
    /**
     * 商品热卖中开关
     */
    productHotEffectEnabled?: boolean;
    /**
     * 商品热卖中文案
     */
    productHotEffectTips?: ChannelProductHotEffectTips;
    /**
     * 点击商品的封面/标题区域是否直接跳转外链
     */
    outLinkProductRedirectEnabled?: boolean;
    /**
     * 商品订单入口是否显示
     */
    productPayOrderEnabled?: boolean;
}

declare interface ChannelConfig_3 {
    /**
     * AI 助手开关
     */
    aiAssistantEnabled?: YN_4;
    /**
     * AI 助手可用状态
     */
    aiAssistantAvailState?: YN_4;
}

/**
 * 观看页频道设置（基础）
 */
export declare interface ChannelConfigBasic {
    /** 音频直播开关 */
    audioOnlyEnabled: YN;
    /** 授权观看条件下 PC 端是否做 302 跳转到观看页 */
    authPcRedirectEnabled: YN;
    /** 微软 AD 授权开关 */
    azureADEnabled: YN;
    /** 直播播放器的弹幕速度 */
    barrageSpeed: string | number;
    /** 直播播放器的弹幕字号 */
    barrageSize: string | number;
    /** 直播短信预约开关 */
    bookingEnabled: YN;
    /** 微信预约弹层提示文案 */
    bookingTips: string;
    /** 隐藏品牌开关 */
    brandHideEnabled: YN;
    /** 频道直播状态轮训间隔，单位：秒 */
    channelLiveStatusQueryFrequency: number;
    /** pv 接口轮询间隔，单位：秒 */
    channelWatchQueryFrequency: number;
    /** 聊天室虚拟人数功能开关 */
    chatRobotEnabled: YN;
    /** 是否开启短信图片验证码开关 */
    checkSmsImageEnabled: YN;
    /** 是否关闭了弹幕功能 */
    closeDanmuEnabled: YN;
    /** 是否关闭提现功能 */
    closeWithdrawEnabled: YN;
    /** 双语直播开关 */
    cnAndEnLiveEnabled: YN;
    /** 直播倒计时开关 */
    countEnabled: YN;
    /** 播放器封面图缩放模式 */
    coverImgType: 'cover' | 'contain';
    /** 默认码率 */
    defaultCodeRate: number | string | null;
    /** 情绪反馈开关，与点赞互斥 */
    emotionEnabled: YN;
    /** 直播间英语独立配置开关 */
    englishSettingEnabled: YN;
    /** 是否只看主持人信息 */
    filterManagerMsgEnabled: YN;
    /** 播放器全屏方案 */
    fullScreenType: FullScreenMode;
    /** 是否跳过微信授权 */
    ignoreWx: YN;
    /** 音频模式类型 */
    isOnlyAudio: ApiAudioModeType;
    /** 日文语言切换（仅用作将英文的文案显示成日文） */
    japLangEnabled: YN;
    /** 竖屏播放器是否允许全屏，默认不允许 */
    playerFullScreen: 'allow' | 'disallow';
    /** 直播 H5 播放器是否使用灰度版本 */
    liveH5PlayerGrayEnabled: YN;
    /** 直播 H5 播放器灰度版本 */
    liveH5PlayerGrayVersion: string;
    /** 直播移动端播放器灰度开关 */
    liveMobilePlayerGrayEnabled: YN;
    /** 直播移动端播放器灰度版本 */
    liveMobilePlayerGrayVersion: string;
    /** 移动端下页面浏览次数显示位置 */
    mobilePvShowLocation: PageViewShowLocation;
    /**
     * 多语言开关（超管）
     * @version 从 v1.1.0 开始不再使用该字段，改用 allowSwitchLangEnabled
     * */
    multilingualEnabled: YN;
    /** 允许观众切换语言开关（后台） */
    allowSwitchLangEnabled: YN;
    /** 多码率开关 */
    multirateEnabled: YN;
    /** 码率列表，用英文逗号隔开 */
    multirates: string | null;
    /** 新版连麦 */
    newMicEnabled: YN;
    /** 泛域名开关 */
    polyvWatchDomainEnabled: YN;
    /** ppt 检查 drawMark 开关 */
    pptCheckDrawMarkEnabled: YN;
    /** ppt avif 图片格式开关 */
    pptUserAvifEnabled: YN;
    /** 商品库事件上报开关 */
    productTrackEnabled: YN;
    /** 商品库链接跳转提示 */
    productLinkJumpTipEnabled: YN;
    /** 商品入口位置 */
    productEntryPosition: ProductEntryPosition;
    /** 商品直接跳转外链开关 */
    outLinkProductRedirectEnabled: YN;
    /** 无延迟计费开关 */
    pureRtcAvailState: YN;
    /** 无延迟直播开关 */
    pureRtcEnabled: YN;
    /** 是否显示页面浏览次数 */
    pvShowEnabled: YN;
    /** 观众发送图片开关 */
    viewerSendImgEnabled: YN;
    /** 提问发送图片开关 */
    questionImageEnabled: YN;
    /** 快直播开关 */
    quickLiveEnabled: YN;
    /** 引用回复开关 */
    quoteReplyEnabled: YN;
    /** 招聘直播开关 */
    recruitmentEnabled: YN;
    /** 红包类型 */
    redPackCurrencyType: RedpackCurrencyType;
    /** 调整红包金额 & 数量上限开关 */
    redPackCustomAmountEnabled: YN;
    /** 观众发送红包的最大金额 */
    redPackViewerMaxAmount: number;
    /** 观众发送红包的最大数量 */
    redPackViewerMaxCount: number;
    /** 直播推流比例：高 */
    resolutionHeight: number;
    /** 直播推流比例：宽 */
    resolutionWidth: number;
    /** 聊天室并发限制开关 */
    restrictChatEnabled: YN;
    /** 是否订阅 rtc 音频流开关 */
    rtcAudioSubEnabled: YN;
    /** 嘉宾云席开关 */
    seatEnabled: YN;
    /** 点赞（送花）开关 */
    sendFlowersEnabled: YN;
    /** 单击点赞（送花）开关 */
    sendFlowersSingleClickEnabled: YN;
    /** 长按点赞（送花）开关 */
    sendFlowersHoldEnabled: YN;
    /** 引导页开关 */
    splashEnabled: YN;
    /** 引导页大图地址 */
    splashLargeImg: string | null;
    /** 引导页布局 */
    splashLayout: MobileSplashLayout;
    /** 投票功能 */
    voteActiveEnabled: YN;
    /** 反馈功能开关 */
    watchFeedbackEnabled: YN;
    /** 欢迎语开关 */
    welcomeEnabled: YN;
    /** 超管后台微信功能开关 */
    weixinAccountFunctionEnabled: YN;
    /** 超管后台中微信支付开关 */
    weixinPayEnabled: YN;
    /** 白板 SDK 开关 */
    whiteboardSdkEnabled: YN;
    /** 企微授权开关 */
    wxWorkAuthSwitch: YN;
    /** 是否绑定企微（后端有额外的业务逻辑处理） */
    wxWorkStatusSwitch: YN;
    /** 企微好友观看限制开关 */
    wxWorkFriendWatchEnabled: YN;
    /** (超管)企微员工邀请开关 */
    wxWorkInviteEnabled: YN;
    /** 私有云场景下，表示拉内网流还是外网流 */
    zone: ZoneType;
    /** 是否自动播放 */
    autoPlayEnabled: YN;
    /** 移动端音频播放开关 */
    mobileAudioEnabled: YN;
    /** 聊天室在线人数显示开关 */
    chatOnlineNumberEnable: YN;
    /** 企微是否已过期 */
    enterpriseWechatExpire: YN;
    /** 自定义favicon */
    faviconCustomUrl: string | null;
    /** 最大提现额度 */
    freePayAmount: number;
    /** 微信支付类型 */
    weixinPayType: WeixinPayType;
    /** 是否显示自定义消息 */
    showCustomMessageEnabled: YN;
    /** 是否启用互动红包 */
    userRedpackEnabled: YN;
    /** 是否启用互动报名抽奖 */
    enrollLotteryEnabled: YN;
    /** 展示下一场次倒计时开关，默认关 */
    showCountdownEnabled: YN;
    /** 海外自动切换线路开关 */
    overseasAutoSwitchEnabled: YN;
    /** 邀请海报开关，默认开 */
    invitePosterEnabled: YN;
    /** 邀约明细下载开关，默认关 */
    inviteDetailExportEnabled: YN;
    /** 分享开关，默认开 */
    shareBtnEnabled: YN;
    /** 分享开关，默认开 */
    shareEnabled: YN;
    /** 特殊授权的观众能否进行微信微信授权，默认关 */
    watchCustomWeixinAuthEnabled: YN;
    /** 直播介绍上传的长图压缩开关，默认开 */
    compressImageEnabled: YN;
    /** 展示预约人数开关，默认开 */
    displayBookingNumberEnabled: YN;
    /** 管理后台-观看页语言设置 */
    watchLangType: 'follow_browser' | LanguageType;
    /** 是否启用手机号脱敏，默认关 */
    badwordMobileEnabled: YN;
    /** 隐藏观众昵称功能，默认关 */
    hideViewerNicknameEnabled: YN;
    /** 是否处于直播测试模式，默认关 */
    isDebug: YN;
    /** 展示黄脸表情(默认表情)，默认开 */
    showDefaultEmoteEnabled: YN;
    /** 展示图片表情(收藏表情)，默认开 */
    showCollectEmoteEnabled: YN;
    /** 分享是否使用回放视频标题，默认关 */
    shareTitleFollowPlaybackVideoEnabled: YN;
    /** 是否启用观看页营销埋点，默认关 */
    watchEventTrackEnabled: YN;
    /** 实时字幕开关，默认关 */
    realTimeSubtitleEnabled: YN;
    /** 实时字幕翻译开关，默认关 */
    subtitleTranslationEnabled: YN;
    /** 实时字幕语言类型 */
    subtitleSourceLanguage: SubtitleSourceLanguage;
    /** 实时字幕翻译语言类型 */
    subtitleTranslationLanguage: SubtitleSourceTranslateLanguage;
    /** 实时字幕翻译语言类型（可选列表） */
    subtitleTranslationLanguages: SubtitleSourceTranslateLanguage[];
    /** 实时字幕显示数量限制开关，默认关 */
    realTimeSubtitleDisplayNumberLimitEnabled: YN;
    /** 实时字幕最多显示条数 */
    realTimeSubtitleDisplayNumber: number;
    /** 实时字幕延迟时长（仅针对无延迟） */
    realTimeSubtitleDisplayDelay: number;
    /** 伪直播实时字幕开关，默认关 */
    realDiskVideoRealTimeSubtitleEnabled: YN;
    /** AI 实时翻译开关，默认关 */
    aiTranslationEnabled: YN;
    /** SaaS 观看时长开关 */
    viewerWatchDurationStatsChannelEnabled: YN;
    /** 观看时长类型/学习时长计算方式 */
    viewerWatchDurationStatsChannelType?: string;
    /** 手机号实名认证开关 */
    viewerVerificationEnabled: YN;
    /** 微信环境支持修改昵称开关，默认关 */
    wxEnvResetNickNameEnabled: YN;
    /** H5 有延迟播放器连麦开关 */
    webH5LinkMicEnabled: YN;
    /** 根据时间戳获取聊天历史记录 */
    getChatHistoryByTimestampEnabled: YN;
    /** 直播时是否显示播放按钮， 默认开 */
    stopLivePlayEnabled: YN;
    /** AI 助手功能计费开关，值为 Y 时可使用 AI 功能 */
    aiAssistantAvailState: YN;
    /** 抽奖按钮中文文案 */
    lotteryGiftButtonTextCH: string;
    /** 抽奖按钮英文文案 */
    lotteryGiftButtonTextEN: string;
    /** 一客一码功能开关(超管)，默认关 */
    userSaleShareEnabled: YN;
    /** 一客一码短信验证码开关，默认关 */
    inviteCustomerSmsCodeEnabled: YN;
    /** 一客一码手机号验证开关，默认关 */
    inviteCustomerMobileCheckEnabled: YN;
    /** 头衔展示开关，默认关 */
    viewerActorEnabled: YN;
    /** 后台观众翻页 */
    viewerPptTurningEnabled: YN;
    /** 一客一码使用场景，默认：wechat */
    inviteCustomerUsageScenario?: 'wechat' | 'browser';
    /** 用户系统 */
    watchUserSystemEnabled: YN;
    /** 公司名 */
    company: string | null;
    /** 公司 logo */
    logoUrl: string | null;
    /** 素材库开关 */
    materialEnabled: YN;
    /** 提示语数据  */
    productLinkJumpTipDetail?: ProductLinkJumpTipDetail;
    /** 是否显示热卖特效 */
    productHotEffectEnabled: YN;
    /** 热卖词数据 */
    productHotEffectTips?: ProductHotEffectTips;
    /** 抽奖隐私协议内容 */
    lotteryPrivacy: string;
    /** 抽奖隐私协议开关 */
    lotteryActivityPrivacyEnabled: YN;
    /** 商品订单入口是否显示 */
    productPayOrderEnabled: YN;
    /** 商品是否支持直接购买开关 */
    innerProduceOrderEnabled: YN;
    /** 竖屏在线列表开关 */
    portraitOnlineListEnabled: YN;
    /** 分组开关 */
    chatViewerGroupEnabled: YN;
    /** 频道用户分组功能开关 */
    channelViewerGroupEnabled: YN;
    /** 限制仅分组用户允许观看开关 */
    onlyGroupWatchEnabled: YN;
    /** Webview 后台小窗是否开启 */
    pictureInPictureEnabled: YN;
    /** Webview 退出应用IOS后台小窗是否开启 */
    pictureInPictureIOSEnabled: YN;
    /** 个人中心开关 */
    personalCenterEnabled: YN;
    /** 监播端跑马灯开关 */
    marqueeEnabled: YN;
    /** 顶部引导条配置 */
    topGuideBar?: ChannelDetailTopGuide;
    /** 其他直播预约提示语 */
    otherChannelBookingTips: {
        bookingTips: string;
        channelId: string;
    }[];
    /** 频道类型 */
    streamType: ChannelStreamType;
    /** 连麦人数限制 */
    linkMicLimit: number | null;
    /** 优惠券开关 */
    couponEnabled: YN;
    /** 邀请观看审核开关 */
    inviteWatchAuditEnabled: YN;
    /** 聊天消息布局 */
    chatMessageLayout: ChatMessageLayout;
    portraitChatMessageLayout: ChatMessageLayout;
    /** 头像是否显示 */
    chatMessageAvatarDisplay: YN;
    portraitChatMessageAvatarDisplay: YN;
    /** 最后一次推流时间 */
    lastPushStreamTime: number | null;
    /** 移动端投诉按钮位置  CONTROL_STRIP_INNER,EXTERNAL */
    mobileComplaintButtonPosition: string;
    /** 当前频道正在推送的商品信息 */
    channelProductPushingStatusVO: ChannelProductPushingStatusInfo_2;
    /** 商品讲解开关 */
    productExplainEnabled: YN;
    /** 直播新场次开关 */
    newSessionEnabled: YN;
    /** 混合流渲染模式 */
    mixStreamRenderMode: MixStreamRenderMode;
    /** 聊天室通知 */
    chatCustomIntroduction: string | null;
    /** 聊天室通知（双语） */
    chatCustomIntroductionEn: string | null;
    /** 安卓增强全屏模式 */
    androidFullScreenEnhancedEnabled: YN;
    /** 低延迟智能播放开关 */
    lowLatencyIntelligentPlayEnabled: YN;
    /** 直播广场 */
    liveSquare: LiveSquare;
    /** 用户体系登录注册方式, 用于判断是否需要企微静默授权 */
    watchUserSystemRegisterLoginType: string;
    /** 商品库开关 */
    liveProductEnabled: YN;
    /** 观看页聊天室 SDK 版本 */
    watchChatSdkVersion: 'v1' | 'v2';
    /** 当前直播场次号 */
    currentSessionId: string | null;
    /** 点赞数开关 */
    likeCountEnabled: YN;
    /** 点赞图标 */
    likeIconUrl: string | null;
    /** 点赞图标类型 */
    likeIconType: string | null;
    /** 自定义点赞图标列表JSON字符串 */
    likeEffectConfig: string | null;
    /** 点赞特效类型 */
    likeEffectType: LikeEffectType;
    /** 商品库横屏位置 */
    productEntryLandscapePosition: 'menuBar' | 'chat';
    /** 商品库图标配置 */
    productListIcon: string | null;
    /** PC小窗播放开关 */
    pcSmallWindowPlayEnabled: YN;
    /** 直播介绍信息卡片开关 */
    descInfoCardEnabled: YN;
}

/**
 * 观看页频道设置（用户）
 */
export declare interface ChannelConfigViewer {
    /** 聊天室翻译开关 */
    chatTranslateEnabled: YN;
    /** 红包开关 */
    redpackEnabled: YN;
    /** 双师大房间频道号 */
    transmitMasterChannelId: string | number | null;
    /** 双师大房间流名称 */
    transmitMasterStream: string | null;
    /** 聊天室是否长时间未使用 */
    watchChatEnabled: YN;
    /** RTC 供应商类型 */
    rtcType: RtcType;
    /** 是否显示邀请海报，除了后台开关配置外，后端还会判断 openId */
    showInviteAccess: YN;
    /** 跑马灯类型 */
    marqueeType: MarqueeType;
    /** 频道转播场景 */
    transmitType: ChannelTransmitType;
    /** 抽奖手动开关 */
    lotteryManualEndEnabled: YN;
    /** 条件抽奖开关 */
    conditionLotteryEnabled: YN;
    /** 条件抽奖是否自动弹窗 */
    conditionLotterySPAutoPopEnabled: YN;
    /** 水印开关 */
    watermarkRestrict: YN;
    /** 水印内容 */
    watermarkType: WatermarkType;
    /** 水印字体大小 */
    watermarkFontSize: WatermarkFontSize;
    /** 水印透明度，0～100，100 为完全透明 */
    watermarkOpacity: string;
    /** 水印内容 */
    watermarkContent: string;
    /** 水印显示类型 */
    watermarkDisplayType: WatermarkDisplayType;
    /** 水印颜色 */
    watermarkColor: string;
    /** 唯一登录校验开关 */
    singleSessionVerify: YN;
    /** 唯一登录校验轮训频率，单位：秒 */
    channelVerifyQueryFrequency: number;
    /** 连麦排序显示开关 */
    showJoinQueueNumberEnabled: YN;
    /** 播放器新版暂停样式开关 */
    newPlayerPauseStyleEnabled: YN;
    /** "我的奖励"开关，默认 Y */
    myRewardsEnabled: YN;
}

/**
 * 倒计时设置
 */
export declare interface ChannelCountdownSetting {
    /** 直播开始时间，单位：时间戳 */
    liveStartTime: number | undefined;
    /** 倒计时开关 */
    countdownEnabled: boolean;
    /** 回放时是否显示下一场倒计时 */
    playbackShowCountdownEnabled: boolean;
}

/**
 * 频道详情
 */
export declare type ChannelDetail = ChannelDetailBasic & ChannelDetailViewer;

/**
 * 频道详情操作
 */
export declare interface ChannelDetailAction {
    /** 是否需要跳转到主会场 */
    mainChannelRedirect: YN;
    /** 是否需要跳转到分会场 */
    subMeetingChannelRedirect: YN;
    /** 跳转分会场的频道号 */
    subMeetingChannelId: number | null;
    /** 不在频道用户分组列表时是否能观看 */
    notInGroupCanWatchEnabled: YN;
}

/**
 * 频道广告相关类型
 */
export declare interface ChannelDetailAdvertSetting extends PageAdvertImageSetting, PageAdvertTextSetting, PageAdvertHrefSetting, HeadAdvertSetting, StopAdvertSetting, IconAdvertSetting {
    /** 页面广告列表 */
    pageAdvertList?: PageAdvertListItem[];
    /** 页面广告开关 */
    pageAdvertEnabled: YN;
    /** 允许关闭页面广告 */
    closeAdvertEnabled: YN;
}

/**
 * 频道详情（基础）
 */
export declare interface ChannelDetailBasic {
    /** 观看条件设置 */
    authSetting: ChannelAuthSetting | null;
    /** 观看页频道设置，包括用户设置 */
    channelConfig: Readonly<ChannelConfigBasic>;
    /** 频道信息 */
    channelInfo: Readonly<ChannelInfoBasic>;
    /** 频道菜单列表 */
    channelMenus: ChannelMenuItem[];
    /** 观看页定制频道信息 */
    customChannelSetting: Readonly<CustomChannelSetting>;
    /** 域名信息 */
    domain: Readonly<ChannelDomain>;
    /** 特效设置 */
    effect: Readonly<ChannelDetailEffectSetting>;
    /** 报名观看设置 */
    enrollSetting?: ChannelEnrollSetting;
    /** 页脚设置 */
    footerSetting: Readonly<ChannelFooterSetting>;
    /** 直播状态数据 */
    liveStatus: Readonly<ChannelLiveStatusBasic>;
    /** 多语言列表 */
    mulitLangList?: ChannelMultiLangItem[];
    /** 分会场设置 */
    multiMeetingSetting?: ChannelMultiMeetingSetting;
    /** 频道主题设置 */
    theme: Readonly<ChannelTheme>;
    /** 互动设置 */
    interactionSetting: Readonly<InteractionSetting>;
    /** 频道观看数据 */
    watchData: ChannelWatchData;
    /** 精彩看点设置 */
    timeAxisMark: ChannelTimeAxisMarkSetting;
    /** 直播时移设置 */
    timeShift: ChannelTimeShiftSetting;
    /** 基础回放设置 */
    playback: ChannelDetailBasicPlayback;
    /** 云席设置 */
    seatSetting?: DetailSeatSetting;
    /** AI 配置 */
    channelAiConfig: ChannelAIConfig;
    /** 讲师信息 */
    channelTeacher: ChannelDetailTeacherInfo;
    /**
     * 用户配置
     * @version v1.11.0
     * */
    userConfig: GlobalUserConfig;
}

/**
 * 基础回放设置
 */
export declare interface ChannelDetailBasicPlayback {
    /** 回放视频名称，需要通过 vid 入参才不为 null */
    playbackVideoName: string | null;
    /** 是否支持快进快退 */
    fastForwardBackwardEnabled: YN;
}

export declare interface ChannelDetailChatInfo {
    /** 房间号 */
    channelRoomId: string | null;
    /** 聊天室连接 token */
    chatToken: string;
}

/**
 * 回传参数对象
 */
export declare interface ChannelDetailEchoParams {
    /** 渠道 id */
    promoteId: string | null;
}

/**
 * 频道消息特效设置
 */
export declare interface ChannelDetailEffectSetting {
    /** 访问特效开关 */
    visitEffectEnabled: YN;
    /** 用户访问直播间 */
    joinVisitEffectTip: string;
    /** 购买转化特效开关 */
    productEffectEnabled: YN;
    /** 用户点击商品-普通商品 */
    clickOrdinaryProductEffectTip: string;
    /** 用户点击商品-金融商品 */
    clickFinancialProductEffectTip: string;
    /** 用户点击商品-职位商品 */
    clickJobProductEffectTip: string;
    /** 用户下单商品-普通商品 */
    orderProductEffectTip: string;
    /** 参与互动特效开关 */
    interactionEffectEnabled: YN;
    /** 用户签到成功 */
    checkinInteractionEffectTip: string;
    /** 用户打赏成功特效 */
    donateInteractionEffectTip: string;
}

declare interface ChannelDetailPlaybackInfo {
    /** 是否开启回放，默认关 */
    enablePlayBack: YN;
    /** 频道播放模式 */
    playMode: ChannelPlayMode;
    /** 聊天重放开关 */
    chatPlaybackEnabled: YN;
    /** 卡片推送重放开关 */
    cardPushPlaybackEnabled: YN;
    /** 签到重放开关 */
    checkInPlaybackEnabled: YN;
    /** 问卷重放开关 */
    questionnairePlaybackEnabled: YN;
    /** 答题卡重放开关 */
    qaPlaybackEnabled: YN;
    /** 商品库重放开关 */
    productPlaybackEnabled: YN;
    /** 是否存在回放视频 */
    hasPlaybackVideo: YN;
    /** 是否存在暂存文件 */
    hasRecordFile: YN;
    /** 回放来源 */
    playbackOrigin: PlaybackType;
    /** 暂存对象 */
    recordFile: PlaybackRecordFile | null;
    /** 回放对象 */
    targetPlaybackVideo: PlaybackVideoTarget | null;
    /** 章节开关 */
    sectionEnabled: YN;
    /** 回放方式 */
    type: PlaybackMode;
    /** 播放场次号 */
    targetSessionId: string | null;
    /** 点播场次号 */
    vodSessionId: string | null;
    /** 点播地址 */
    vodUrl: string | null;
    /** 点播用户状态 */
    vodUserStatus: YN;
    /** 回放字幕列表 */
    subtitleList: ReplaySubtitleItem[];
    /** 回放时是否显示倍速按钮，默认开 */
    playbackMultiplierEnabled: YN;
    /** 回放时是否显示进度条，默认开 */
    playbackProgressBarEnabled: YN;
    /** 回放时是否显示左下角播放/暂停按钮，默认开 */
    showPlayButtonEnabled: YN;
    /** 回放时是否循环播放，列表播放播放完最后一个视频会暂停播放，默认开 */
    loopPlayEnabled: YN;
    /** 回放时 回放大纲开关 默认开 */
    aiSummaryEnabled: YN;
    /** 回放时 互动答题开关 */
    aiKnowledgeQuizEnabled: YN;
    /** 回放列表是否显示开始时间， 默认开 */
    listLiveStartTimeEnabled: YN;
}

/**
 * 播放器设置
 */
export declare interface ChannelDetailPlayerSetting {
    /** 弹幕是否默认显示 */
    showDanmuInfoEnabled: YN;
    /** 播放器 logo 图片地址 */
    logoImage: string | null;
    /** 播放器 logo 跳转地址 */
    logoHref: string | null;
    /** 播放器 logo 透明度，0～1 */
    logoOpacity: number;
    /** 播放器 logo 位置 */
    logoPosition: PlayerLogoPosition;
    /** 安卓下是否显示倍速按钮 */
    androidXSpeedPlayEnabled: YN;
}

/**
 * 公众号关注信息
 */
export declare interface ChannelDetailPromotion {
    /** 关注是否自动打开 */
    followAutoShow: YN;
    /** 关注开关 */
    followEnabled: YN;
    /** 关注入口文案 */
    followEntrance: string;
    /** 关注图片 */
    followImage: string;
    /** 移动端关注提示 */
    followTips: string;
    /** PC端关注提示 */
    pcFollowTips: string;
    /** 邀约明细开关，默认关 */
    inviteDetailEnabled: YN;
}

export declare interface ChannelDetailRequestParams {
    /** 频道号 */
    channelId: string;
}

export declare interface ChannelDetailResult {
    channelDetailBasic: ChannelDetailBasic;
    channelDetailViewer: ChannelDetailViewer;
    channelDetail: ChannelDetail;
}

/**
 * 频道讲师信息
 */
export declare interface ChannelDetailTeacherInfo {
    /** 头衔 */
    actor: string;
    /** 头像地址 */
    avatar: string;
    /** 昵称 */
    nickName: string;
    /** 主讲Id，关联主讲的时候才有值 */
    anchorId?: number;
}

/**
 * 顶部引导条配置
 */
export declare interface ChannelDetailTopGuide {
    topGuideBarEnabled: YN;
    topGuideBarLogo: string;
    topGuideBarContent: string;
    topGuideBarButtonContent: string;
    topGuideBarAndroidRedirectUrl: string;
    topGuideBarIosRedirectUrl: string;
    topGuideBarHarmonyOSRedirectUrl: string;
    topGuideBarCloseable: YN;
}

/**
 * 频道详情（用户）
 */
export declare interface ChannelDetailViewer extends ChannelDetailViewerPlaybackInfo {
    /** 频道详情操作 */
    action: ChannelDetailAction;
    /** 频道配置 */
    channelConfig: Readonly<ChannelConfigViewer>;
    /** 频道信息 */
    channelInfo: Readonly<ChannelInfoViewer>;
    /** 当前频道的打赏设置 */
    donateSetting: ChannelDonateSetting | null;
    /** 频道观看者信息 */
    viewerChannelPromotion: ViewerChannelPromotion;
    /** 报名观看信息 */
    enrollInfo?: ChannelEnrollInfo;
    /** 观众信息 */
    viewerInfo?: ViewerInfo;
    /** 观众唯一信息 */
    viewerUnionInfo?: ViewerUnionInfo;
    /** 短信预约信息 */
    smsBooking?: SmsBooking;
    /** 微信预约信息 */
    wxBooking?: WxBooking;
    /** 自定义预约信息 */
    customBooking?: SmsBooking;
    /** 观众微信信息 */
    wxInfo?: WxInfo;
    /** 聊天室信息 */
    chatInfo?: ChannelDetailChatInfo;
    /** 频道菜单列表(观众) */
    channelMenus: ChannelMenuItem[];
    /** 频道广告配置 */
    channelAdvert?: ChannelDetailAdvertSetting;
    /** 播放器设置 */
    playerSetting?: ChannelDetailPlayerSetting;
    /** 邀请对象 */
    invite?: ChannelDetailViewerInvite;
    /** 回传参数对象 */
    echoParams?: ChannelDetailEchoParams;
    /** 讲师信息 */
    channelTeacher?: ChannelDetailTeacherInfo;
    /** 关注信息 */
    channelPromotion?: ChannelDetailPromotion;
    /** 金融-风险测评 */
    riskEvaluation?: FinanceRiskEvaluation | null;
    /** 金融-风险确认函 */
    riskConfirm?: FinanceRiskConfirmSetting | null;
    /** 云席信息 */
    viewerSeat: DetailViewerSeatInfo | null;
    /** 一客一码邀请信息 */
    inviteCustomer?: ChannelViewerInviteCustomer;
    /** 邀请观看邀请信息 */
    inviteWatch?: ChannelViewerInviteWatchInfo | null;
    /** 下一场直播短信预约信息 */
    otherChannelSmsBooking?: OtherChannelSmsBooking;
    /** 下一场直播微信预约信息 */
    otherChannelWxBooking?: OtherChannelWxBooking;
    /** 下一场直播自定义预约信息 */
    otherChannelCustomBooking?: OtherChannelCustomBooking;
}

export declare interface ChannelDetailViewerInvite {
    /** 邀请ID */
    invitePosterId: string;
    /** 邀请者信息 */
    inviteUser: ChannelDetailViewerInviteUser | null;
}

export declare interface ChannelDetailViewerInviteUser {
    /** 邀请者的 openId */
    inviteOpenId: string;
    /** 邀请者的 unionId */
    inviteUnionId: string;
    /** 邀请者的昵称 */
    inviteNickname: string;
}

/**
 * 频道详情（用户-回放信息）
 */
export declare interface ChannelDetailViewerPlaybackInfo {
    /** 直播状态数据 */
    liveStatus?: Readonly<ChannelLiveStatusViewer>;
    /** 频道菜单列表(观众) */
    channelMenus?: ChannelMenuItem[];
    /** 回放配置 */
    playbackInfo?: ChannelDetailPlaybackInfo | null;
}

/**
 * 域名信息
 */
export declare interface ChannelDomain {
    /** 静态资源域名 */
    assetsUrlPrefix: string;
    /** 观看页域名 */
    watchDomain: string;
    /** 聊天室 api 域名，不带协议 */
    chatApiDomain: string;
    /** 聊天室域名 */
    chatDomain: string;
    /** 直接购买的黑名单域名 */
    blockInnerProductOrderDomains: string[];
}

/** 打赏设置 */
export declare interface ChannelDonateSetting {
    /** 现金打赏最低限制 */
    cashMin: number;
    /** 现金打赏金额列表 */
    cashes: number[];
    /** 现金打赏开关 */
    donateCashEnabled: YN;
    /** 道具（现金）打赏开关 */
    donateGoodEnabled: YN;
    /** 道具（积分）打赏开关 */
    donatePointEnabled: YN;
    /** 积分礼物单位 */
    pointUnit: string;
    /** 积分单位 */
    scoreUnit: string;
    /** 道具列表 */
    goods?: DonateGoodBasicData[];
    /** 积分道具列表 */
    pointGoods?: DonateGoodBasicData[];
}

/**
 * 频道消息特效设置
 */
export declare interface ChannelEffectSetting {
    /** 访问特效开关 */
    visitEffectEnabled: boolean;
    /** 用户访问直播间 */
    joinVisitEffectTip: string;
    /** 购买转化特效开关 */
    productEffectEnabled: boolean;
    /** 用户点击商品-普通商品 */
    clickOrdinaryProductEffectTip: string;
    /** 用户点击商品-金融商品 */
    clickFinancialProductEffectTip: string;
    /** 用户点击商品-职位商品 */
    clickJobProductEffectTip: string;
    /** 用户下单商品-普通商品 */
    orderProductEffectTip: string;
    /** 参与互动特效开关 */
    interactionEffectEnabled: boolean;
    /** 用户签到成功 */
    checkinInteractionEffectTip: string;
    /** 用户打赏成功特效 */
    donateInteractionEffectTip: string;
}

/**
 * 频道报名信息
 */
export declare interface ChannelEnrollInfo {
    /** 是否已审核 */
    hasAudited: YN;
    /** 是否已经报名观看 */
    hasEnrolled: YN;
}

/**
 * 报名观看设置
 */
export declare interface ChannelEnrollSetting {
    /** 是否需要审核 */
    auditEnabled: YN;
    /** 表单头图 */
    banner: string | null;
    /** 报名观看开关 */
    enabled: YN;
    /** 报名观看入口文本 */
    entranceText: string | null;
    /** 填写时机 */
    fillTime: EnrollFillTime;
    /** 报名标题 */
    title: string;
    /** 表单字段 */
    fields: EnrollFieldItem[];
}

/**
 * 频道模块事件
 * @eventenum {@link ChannelEventsRelations}
 */
export declare enum ChannelEvents {
    /**
     * 频道安装失败
     * @version v0.3.2
     * @description 安装 channel 模块失败时会触发该事件
     *  */
    ChannelSetupFail = "ChannelSetupFail",
    /**
     * 直播状态改变事件
     * @description 当主讲开始/结束直播后，频道的直播状态都会改变，通过该事件监听直播状态改变
     * @example
     * ```js
     * watchCore.channel.eventEmitter.on(ChannelEvents.LiveStatusChange, (data) => {
     *   console.log('频道状态改变，新状态：', data.liveStatus);
     * });
     * ```
     */
    LiveStatusChange = "LiveStatusChange",
    /**
     * 场次号改变事件
     * @description 主讲开次新的一次直播后，都会生成一个新的直播场次号，可以通过频道模块的该事件监听直播场次号改变。
     * @example
     * ```js
     * watchCore.channel.eventEmitter.on(ChannelEvents.LiveStatusChange, (data) => {
     *   console.log('频道状态改变，新状态：', data.liveStatus);
     * });
     * ```
     */
    SessionIdChange = "SessionIdChange",
    /**
     * 研讨会主持加入分组讨论事件
     * @desc 研讨会频道才会触发的事件
     * @version v0.7.0
     */
    SeminarHostJoinInGroup = "SeminarHostJoinInGroup",
    /**
     * 研讨会主持离开分组讨论事件
     * @desc 研讨会频道才会触发的事件
     * @version v0.7.0
     */
    SeminarHostLeaveGroup = "SeminarHostLeaveGroup",
    /**
     * 强制切换到回放状态
     * @version v0.7.0
     * @internal
     * @ignore
     */
    ForceChangePlaybackStatus = "ForceChangePlaybackStatus",
    /**
     * 观众累计观看时长
     * @version v0.8.0
     * @example
     * ```js
     * watchCore.channel.eventEmitter.on(ChannelEvents.ViewerWatchDuration, (data) => {
     *   console.log('观众累计观看时长', data.duration);
     * });
     * ```
     */
    ViewerWatchDuration = "ViewerWatchDuration",
    /**
     * 转播双师房间切换
     * @version v0.9.0
     */
    TransmitDoubleRoomChange = "TransmitDoubleRoomChange",
    /**
     * 关联转播状态变更
     * @version v0.10.0
     */
    TransmitChannelSwitch = "TransmitChannelSwitch",
    /**
     * 管理员公告跑马灯
     * @version v2.0.0
     */
    ManagerBulletinMarquee = "ManagerBulletinMarquee",
    /**
     * 测试模式变更
     * @desc 只对普通观众生效，已通过测试 token 进入观看页的观众不会触发该回调
     * @version v2.0.0
     */
    TestModeChange = "TestModeChange",
    /**
     * 授权过期
     * @version v2.7.0
     */
    AuthExpired = "AuthExpired"
}

/**
 * 频道模块事件回调参数配置
 */
export declare type ChannelEventsRelations = {
    [ChannelEvents.ChannelSetupFail]: {
        /**
         * 频道安装失败原因
         */
        failReason: ChannelSetupFailReason;
        /**
         * 频道安装失败信息
         */
        failMessage?: string;
    };
    [ChannelEvents.LiveStatusChange]: {
        /**
         * 新的直播状态
         */
        liveStatus: LiveStatus;
        /**
         * 新的直播状态
         * @version v2.5.0
         */
        newLiveStatus: LiveStatus;
        /**
         * 旧的直播状态
         * @version v2.5.0
         */
        oldLiveStatus: LiveStatus;
    };
    [ChannelEvents.SessionIdChange]: {
        /**
         * 新的场次号
         */
        sessionId: string;
    };
    [ChannelEvents.ViewerWatchDuration]: {
        /**
         * 累计观看时长，单位秒
         */
        duration: number;
    };
    [ChannelEvents.TransmitDoubleRoomChange]: {
        /**
         * 切换到哪个类型的房间: main(主房间)，child(子房间)
         */
        to: 'main' | 'child';
        /**
         * 房间 Id
         */
        roomId: string;
    };
    [ChannelEvents.TransmitChannelSwitch]: {
        /**
         * 开关
         */
        enabled: boolean;
    };
    [ChannelEvents.ManagerBulletinMarquee]: {
        /**
         * 开关
         */
        enabled: boolean;
    };
    [ChannelEvents.TestModeChange]: {
        /**
         * 当前是否处于测试模式
         */
        inTestMode: boolean;
    };
};

export declare interface ChannelFileListItem {
    /** 文件 id - 必填字段 */
    id: string;
    /** 文件名称 - 必填字段 */
    name: string;
    /** 文件地址 */
    url?: string;
    /** 文件大小, 旧数据为0 */
    fileSize?: number;
    /** 文件上传时间 */
    time?: number;
    /** 消息来源 */
    msgSource?: ChannelFileMsgSource.File;
}

export declare enum ChannelFileMsgSource {
    File = "file"
}

/**
 * 频道关注设置
 */
export declare interface ChannelFollowSetting {
    /** 关注开关 */
    followEnabled: boolean;
    /** 主动弹窗 */
    followAutoShow: boolean;
    /** 入口文案 */
    followEntrance: string;
    /** 二维码图片 */
    followImage: string | undefined;
    /** 移动端弹窗提示文案 */
    followTips: string | undefined;
    /** PC端弹窗提示文案 */
    pcFollowTips: string | undefined;
}

/**
 * 页脚设置
 */
export declare interface ChannelFooterSetting {
    /** 页脚链接域名，如：https:// */
    footTextLinkProtocol: string;
    /** 页脚链接地址，如：www.polyv.net */
    footTextLinkUrl: string;
    /** 页脚文案 */
    footerText: string;
    /** 页脚开关 */
    showFooterEnabled: YN;
}

/**
 * 频道图标广告设置
 */
export declare interface ChannelIconAdvertSetting {
    /** 图标广告开关 */
    imgAdvertEnabled: boolean;
    /** 图标广告是否可关闭 */
    closeImgAdvertEnabled: boolean;
    /** 图标广告列表 */
    imgAdvertList: IconAdvertItem[];
}

/**
 * 频道信息
 */
declare interface ChannelInfo {
    /**
     * 频道号
     */
    channelId?: string;
    /**
     * 场次号
     */
    sessionId?: string;
    /**
     * 直播状态
     */
    liveStatus?: string;
    /**
     * 保利威账号 id
     */
    accountId?: string;
    /**
     * 观看页地址
     */
    watchUrl?: string;
    /**
     * 邀请地址
     */
    inviteUrl?: string;
}

/**
 * 频道信息
 */
declare interface ChannelInfo_2 {
    /**
     * 频道号
     */
    channelId?: string;
}

/**
 * 频道信息（基础）
 */
export declare interface ChannelInfoBasic {
    /** 频道号 */
    channelId: number;
    /** 聊天室背景图类型 */
    chatBackgroundType: BackgroundType;
    /** 聊天室背景图 */
    chatBackgroundImage: string;
    /** 聊天室背景图透明度，0 ～ 100 */
    chatBackgroundImageOpacity: number;
    /** 竖屏聊天区背景图类型 */
    portraitChatBgType: BackgroundType;
    /** 竖屏聊天区背景图 */
    portraitChatBgImg: string;
    /** 竖屏聊天区背景图透明度，0 ～ 100 */
    portraitChatBgImgOpacity: number;
    /** 竖屏播放器画面适配类型 */
    playerPortraitScreenType: PortraitPlayerScreenType;
    /** 播放器背景图类型 */
    playerBackgroundType: BackgroundType;
    /** 播放器背景图 */
    playerBackgroundImage: string;
    /** 播放器背景图透明度，0 ～ 100 */
    playerBackgroundImageOpacity: number;
    /** 频道图标 */
    coverImg: string;
    /** 自定义浏览器标签页图标，需要走定制路径才能用 */
    customIcon: string | null;
    /** 频道介绍 */
    description: string;
    /** 观看页是否被关闭 */
    isClosePreview: YN;
    /** 移动端观看开关 */
    mobileEnabled: YN;
    /** 频道名称 */
    name: string;
    /** 直播场景 */
    newScene: ChannelNewScene;
    /** 频道主持人名称 */
    publisher: string;
    /**
     * 分房间下所有的子房间列表，用英文逗号隔开，仅开启手动分房间下才有值
     * @desc 现在已改用自动分房间，无需处理
     *  */
    roomIds: string | null;
    /** 频道场景 */
    scene: ChannelScene;
    /** 引导页封面图 */
    splashImg: string;
    /** 引导页封面图背景 id */
    splashImgBackgroundId: number | null;
    /** 直播开始时间 */
    startTime: number | null;
    /** 保利威账号 userId */
    userId: string;
    /** 暖场图片地址 */
    warmImage: string;
    /** 暖场大图图片地址 */
    warmLargeImage: string | null;
    /** 暖场图/播放器比例 */
    warmUpResolutionRatio: '16:9' | '9:16';
    /** 观看地址 */
    watchCodeUrl: string;
    /** 观看页布局 */
    watchLayout: MobileWatchLayout;
    /** web 分享自定义地址 */
    webShareCustomUrl: string | null;
    /** 是否开启网页自定义分享地址参数，默认关 */
    webShareCustomUrlWithParamEnabled: YN;
    /** 双流封面跳转地址 */
    coverJumpUrlEn?: string;
    /** 双流封面图片地址 */
    coverImageEn?: string;
}

/**
 * 频道信息（用户）
 */
export declare interface ChannelInfoViewer {
    /** 频道类型 */
    channelType: ChannelType;
}

/**
 * 邀请有礼活动
 */
export declare interface ChannelInvitePrizeActivity {
    /** 邀请有礼活动id */
    id: string | null;
    /** 邀请有礼开关，默认关 */
    invitePrizeEnabled: YN;
    /** 邀请有礼活动介绍 */
    introduction: string | null;
    /** 邀请有礼活动截至时间，时间戳 */
    endTime: number | null;
    /** 邀请有礼活动状态 */
    status: InviteActivityStatus | null;
}

/**
 * 频道多语言设置
 */
export declare interface ChannelLangSetting {
    /**
     * 优先使用推荐配置
     * @version v1.1.0
     */
    preferRecommendSetting: boolean;
    /** 双语界面开关 */
    englishSettingEnabled: boolean;
    /**
     * AI 多语言翻译开关
     * @version v2.17.0
     */
    aiTranslationEnabled: boolean;
    /** 多语言开关 */
    langSwitchEnabled: boolean;
    /** 是否显示七国多语言 */
    isShowSevenLanguage: boolean;
    /** 是否将英文选择文案替换成日语文案 */
    japLangEnabled: boolean;
    /** 是否跟随浏览器语言 */
    isFollowBrowserLang: boolean;
    /** 观看页默认配置的语言类型 */
    defaultLangType: LanguageType;
}

/**
 * 频道布局设置
 */
export declare interface ChannelLayoutSetting {
    /** 三分屏主屏幕布局模式 */
    mainScreenLayoutMode: MainScreenLayoutMode;
    /** 移动端引导页布局 */
    mobileSplashLayout: MobileSplashLayout;
    /** 移动端观看页布局 */
    mobileWatchLayout: MobileWatchLayout;
}

/**
 * 频道直播状态数据（基础）
 */
export declare interface ChannelLiveStatusBasic {
    /** 测试模式 */
    testModeStatus: YN;
    /** 观看页状态 */
    watchStatus: LiveStatus;
}

/**
 * 频道直播状态数据（用户）
 */
export declare interface ChannelLiveStatusViewer {
    /** 频道禁推流开关 */
    banPushStream: YN;
    /** 频道场次号（在新建没直播过、研讨会的频道为 null） */
    channelSessionId: string | null;
    /** 当前频道流 */
    currentStream: string;
    /** 直播状态 */
    liveStatus: LiveStatus;
    /** 流状态是否正在直播 */
    streamStatus: YN;
    /** 回放禁流开关 */
    playbackForbidden: YN;
}

/**
 * 频道菜单 iframe 打开方式枚举
 */
export declare enum ChannelMenuIframeOpenType {
    /** 在菜单内显示 */
    MenuDisplay = "menuDisplay",
    /** 在当前页打开 */
    CurrentPage = "currentPage",
    /** 在新页面打开 */
    NewPage = "newPage"
}

/**
 * @file 频道菜单信息
 */

/** 频道菜单节点 */
export declare interface ChannelMenuItem {
    /** 菜单唯一表示 */
    menuId: string;
    /** 菜单类型 */
    menuType: ChannelMenuType;
    /** 菜单名称 */
    name: string;
    /** 菜单内容 */
    content?: string;
    /** 自定义菜单是否实时更新 */
    realTimeFlushEnabled?: YN;
    /** iframe 打开方式 */
    iframeOpenType?: ChannelMenuIframeOpenType;
    /** 是否显示该菜单，目前仅 chat 类型菜单支持控制 */
    displayEnabled?: YN;
    /** 链接类型 */
    linkType?: number;
}

/**
 * 频道菜单类型枚举
 */
export declare enum ChannelMenuType {
    /** 直播介绍 */
    Desc = "desc",
    /** 聊天室 */
    Chat = "chat",
    /** 自定义图文 */
    Text = "text",
    /** 嘉宾云席 */
    Seat = "seat",
    /** 提问 */
    Quiz = "quiz",
    /** 推广外链 */
    Iframe = "iframe",
    /** 回放列表 */
    Previous = "previous",
    /** 图文直播 */
    Tuwen = "tuwen",
    /** 问答 */
    QA = "qa",
    /** 商品库 */
    Buy = "buy",
    /** 实时字幕 */
    Subtitle = "realTimeSubtitle",
    /** 邀请榜 */
    Invite = "invite",
    /** 成员列表 */
    Members = "members",
    /** 投票 */
    Vote = "vote",
    /** 微活动 */
    MicroActivity = "microActivity",
    /** 分会场 */
    MultiMeeting = "multiMeeting",
    /** AI 助手答疑 */
    AIAssistant = "aiAssistant",
    /** AI 看 */
    AISummary = "aiSummary"
}

/**
 * 频道信息
 */
export declare interface ChannelModuleInfo {
    /** 频道号 */
    channelId: string;
    /** 频道类型，默认：{@link ChannelScene.Alone} */
    scene: ChannelScene;
    /** 观看页浏览次数 */
    pageViewCount: number;
    /** 频道最新的 sessionId，没有时为空字符传 */
    currentSessionId: string;
    /** 直播状态 */
    liveStatus: LiveStatus;
    /** 当前频道的直播流 */
    currentStream: string | undefined;
    /** 频道转播类型 */
    transmitType: ChannelTransmitType;
    /** 转播双师是否监听主频道/主房间 */
    transmitListenMain: boolean;
    /** 转播双师下主频道流名称 */
    transmitMasterStream: string | undefined;
    /** 转播双师下主频道的频道号 */
    transmitMasterChannelId: string | undefined;
    /** 当前频道是否处于测试模式 */
    testModeStatus: boolean;
    /** 当前频道是否处于直播测试模式 */
    liveTestMode: boolean;
    /**
     * @version v0.7.0
     * 当前频道是否支持回放
     * */
    playbackEnabled: boolean;
    /**
     * @version v2.13.0
     * 频道直播场景
     */
    newScene: ChannelNewScene;
}

/**
 * 多语言信息
 */
export declare interface ChannelMultiLangItem {
    /** 语言 */
    lang: 'EN' | 'CN';
    /** 菜单列表 */
    menuList: ChannelMenuItem[];
    /** 主持人名称 */
    publisher: string;
    /** 频道标题 */
    title: string;
}

/**
 * 分会场信息
 */
export declare interface ChannelMultiMeetingItem {
    /** 频道号 */
    channelId: number;
    /** 分会场名称 */
    multiMeetingName: string;
    /** 引导页封面图 */
    splashImg: string | null;
}

/**
 * 分会场设置
 */
export declare interface ChannelMultiMeetingSetting {
    /** 当前是否为分会场 */
    isSubChannel: YN;
    /** 主会场的频道号 */
    mainChannelId: number;
    /** 分会场开关 */
    multiMeetingEnabled: YN;
    /** 分会场列表 */
    multiMeetings: ChannelMultiMeetingItem[];
    /** 分会场模板 */
    multiMeetingListLayout: MultiMeetingListLayout;
    /** 分会场入口名称 */
    multiMeetingEntranceName: string;
}

/**
 * 频道直播场景枚举
 */
export declare enum ChannelNewScene {
    /** 未定义 */
    Undefined = "undefined",
    /** 大班课 */
    TopClass = "topclass",
    /** 企业培训 */
    Train = "train",
    /** 双师课 */
    Double = "double",
    /** 研讨会 */
    Seminar = "seminar",
    /** 活动营销 */
    Alone = "alone",
    /** 带货直播 */
    Portrait = "portrait",
    /** 会议模式 */
    Meeting = "meeting",
    /** MR 直播 */
    Mr = "mr",
    /** 小班课 */
    SmallClass = "smallclass"
}

/**
 * 频道页脚设置
 */
export declare interface ChannelPageFooterSetting {
    /** 页脚开关 */
    footerEnabled: boolean;
    /** 页脚文案 */
    footerText: string;
    /** 页脚完整链接 */
    footerLink: string;
    /** 页脚链接域名，如：https:// */
    footerTextLinkProtocol: string;
    /** 页脚链接地址，如：www.polyv.net */
    footerTextLinkUrl: string;
}

/**
 * 频道播放模式
 */
export declare enum ChannelPlayMode {
    /** 暖场 */
    Warm = "warm",
    /** 暂存录制 */
    Record = "record",
    /** 回放 */
    Playback = "playback",
    /** 直播 */
    Live = "live",
    /** 结束 */
    End = "end"
}

/**
 * 频道商品热卖中文案
 */
declare interface ChannelProductHotEffectTips {
    /**
     * 金融产品热卖中文案
     */
    financeProductTips: string;
    /**
     * 职位产品热卖中文案
     */
    jobProductTips: string;
    /**
     * 普通产品热卖中文案
     */
    normalProductTips: string;
}

/**
 * 频道商品推送状态信息
 */
declare interface ChannelProductPushingStatusInfo {
    productId: number;
    pushRule: 'bigCard' | 'smallCard';
}

/** 频道推流信息 */
export declare interface ChannelPushInfo {
    /** 是否使用导播台推流 */
    isNewGuide: YN;
    /** 推流高度 */
    resolutionHeight: number;
    /** 推流宽度 */
    resolutionWidth: number;
    /** 推流端是否支持 rtc 连麦 */
    rtcEnabled: YN;
    /** 推流类型 */
    streamType: StreamType;
}

/**
 * @file 频道相关的枚举
 */
/**
 * 频道场景枚举
 */
export declare enum ChannelScene {
    /** 普通频道 */
    Alone = "alone",
    /** 三分屏 */
    Ppt = "ppt",
    /** 研讨会 */
    Seminar = "seminar"
}

export declare interface ChannelSessionDataItem {
    /** 场次id */
    sessionId: string;
    /** 场次名称 */
    name: string;
    /** 创建时间 */
    createdTime: number;
    /** 实际开播时间 */
    startTime: number;
    /** 实际结束时间 */
    endTime: number;
    /** 计划开始时间 */
    planStartTime: number;
    /** 计划结束时间 */
    planEndTime: number;
    /** 封面图相关 */
    splashImg: string;
    splashLargeImg: string;
    splashImgBackgroundId: number;
    status: ChannelSessionStatus;
}

/**
 * 频道场次状态
 */
export declare enum ChannelSessionStatus {
    /** 未开始 */
    UnStart = "unStart",
    /** 已结束 */
    End = "end",
    /** 直播中 */
    Live = "live",
    /** 回放中 */
    Playback = "playback",
    /** 已过期 */
    Expired = "expired"
}

/** 频道安装失败原因 */
export declare enum ChannelSetupFailReason {
    /** 网络错误 */
    NetworkError = "NetworkError",
    /** 网络请求超时 */
    NetworkRequestTimeout = "NetworkRequestTimeout",
    /** 不被允许的域名 */
    NotAllowDomain = "NotAllowDomain",
    /** 禁止访问 */
    NotAllowAccess = "NotAllowAccess",
    /** 不是可用的场次 */
    NotAvailableSession = "NotAvailableSession",
    /** 未知错误 */
    Unknown = "Unknown"
}

/**
 * 频道流多轨配置（双流）
 */
export declare interface ChannelStreamTrackConfig {
    /** 多轨配置类 */
    type: ChannelStreamTrackType;
    /** 多轨列表 */
    trackList: ChannelStreamTrackItem[];
}

export declare interface ChannelStreamTrackItem {
    /** 用于参考的轨道名称 */
    name: string;
    /** 轨道 Key 值 */
    key: string;
    /** 语言（多音轨时才有） {@link ChannelStreamTrackType.MultiLanguageTrack } */
    lang?: LanguageType;
}

export declare enum ChannelStreamTrackType {
    /** 单轨道 */
    Single = "Single",
    /** 正常多轨 */
    Normal = "Normal",
    /** 多语言轨道 */
    MultiLanguageTrack = "MultiLanguageTrack"
}

/** 频道类型 */
export declare enum ChannelStreamType {
    /** 客户端推流 */
    Client = "client",
    /** 拉流直播 */
    Pull = "pull",
    /** 第三方拉流 */
    ThirdPull = "thirdpull",
    /** 硬盘推流, 伪直播  */
    Disk = "disk",
    /** 音频直播 */
    Audio = "audio",
    /** VR直播 */
    Vr = "vr"
}

/**
 * 观看页主体信息
 */
export declare interface ChannelTheme {
    /** PC 端观看页背景图 */
    customPCWatchBackgroundImage: string | null;
    /** 新版观看页皮肤 */
    newPageSkin: ChannelWatchPageSkin;
    /** 观看页主题 */
    theme: string;
    /** 观看页主题类型 */
    styleType: ChannelWatchThemeStyleType;
    /** 三分屏布局 */
    watchLayout: MainScreenLayoutMode;
}

/**
 * 频道皮肤主题设置
 */
export declare interface ChannelThemeSetting {
    /** 观看页皮肤 */
    pageSkin: ChannelWatchPageSkin;
    /**
     * 观看页主题
     * @version v2.14.0
     */
    watchTheme: string | null;
    /**
     * 样式类型
     * @description 用来判断使用 pageSkin 还是 watchTheme
     * @version v2.14.0
     */
    styleType: ChannelWatchThemeStyleType;
    /** 浏览器标签页图标 */
    browserFavIcon: string;
    /** 频道图标图片地址 */
    channelCoverImg: string;
    /** 引导页封面图 */
    splashImg: string;
    /** 引导页封面图背景 id */
    splashImgBackgroundId: number | undefined;
    /** 移动端引导页大图 */
    mobileSplashLargeImg: string;
    /** PC 端观看页背景图 */
    pcWatchBackgroundImage: string | undefined;
    /** 移动端聊天室背景图类型 */
    mobileChatBackgroundType: BackgroundType;
    /** 移动端聊天室背景图 */
    mobileChatBackgroundImage: string | undefined;
    /** 聊天室背景图模糊，0 ～ 100 */
    mobileChatBackgroundImageAmbiguity: number | undefined;
    /** 竖屏背景图类型 */
    portraitBackgroundType: BackgroundType;
    /** 竖屏背景图 */
    portraitBackgroundImage: string | undefined;
    /** 竖屏背景图透明度，0 ～ 100 */
    portraitBackgroundImageAmbiguity: number | undefined;
    /** 播放器背景图类型 */
    playerBackgroundType: BackgroundType;
    /** 播放器背景图 */
    playerBackgroundImage: string | undefined;
    /** 播放器背景图透明度，0 ～ 100 */
    playerBackgroundImageAmbiguity: number | undefined;
    /** 直播介绍信息卡片开关，默认开启 */
    descInfoCardEnabled: boolean;
}

/**
 * 精彩看点(打点)设置
 */
export declare interface ChannelTimeAxisMarkSetting {
    /** 直播打点是否启用，默认关 */
    liveTimeAxisMarkEnabled: YN;
    /** 回放打点是否启用，默认关 */
    playbackTimeAxisMarkEnabled: YN;
}

/**
 * 直播时移设置
 */
export declare interface ChannelTimeShiftSetting {
    /** 直播时移功能是否启用，默认关 */
    timeShiftEnabled: YN;
    /** 服务端记录的开始推流时间戳 */
    pushStreamStartTime: number;
    /** 当前播放时间戳 */
    currentTime: number;
}

/**
 * 频道令牌数据
 */
declare interface ChannelTokenData {
    channelToken: string;
}

/**
 * 顶部引导条配置
 */
export declare interface ChannelTopGuideSetting {
    /** 引导条开关 */
    topGuideBarEnabled: boolean;
    /** 顶部 LOGO */
    topGuideBarLogo: string;
    /** 引导条文案 */
    topGuideBarContent: string;
    /** 按钮文案 */
    topGuideBarButtonContent: string;
    /** 跳转链接：安卓 */
    topGuideBarAndroidRedirectUrl: string;
    /** 跳转链接：iOS */
    topGuideBarIosRedirectUrl: string;
    /** 跳转链接：鸿蒙 */
    topGuideBarHarmonyOSRedirectUrl: string;
    /** 是否允许关闭 */
    topGuideBarCloseable: boolean;
}

/**
 * 频道转播场景
 */
export declare enum ChannelTransmitType {
    /** 单讲师 */
    Single = "single",
    /** 双师 */
    Double = "double"
}

/** 试看错误类型 */
export declare enum ChannelTrialError {
    /** 未知错误 */
    Unknown = "Unknown",
    /** 重定向 */
    Redirect = "Redirect"
}

/** 频道试看信息 */
export declare interface ChannelTrialInfo {
    /** 频道场次ID */
    channelSessionId: string;
    /** 观看条件设置的试看时长，以分钟为单位 */
    trialWatchTime: number;
    /** 剩余可用试看时长 */
    availableTrial: number;
    /** 是否付费标志（Y/N） */
    hasPay: YN;
    /** 付费价格 */
    price: number;
    /** 观众信息 */
    viewerInfo: ViewerInfo;
}

/**
 * 频道类型
 */
export declare enum ChannelType {
    /** 常规频道 */
    Normal = "normal",
    /** 发起转播频道 */
    Transmit = "transmit",
    /** 接收转播频道 */
    Receive = "receive"
}

/**
 * 频道用户分组配置
 */
export declare interface ChannelViewerGroupConfig {
    /** 聊天用户分组功能开关 */
    chatViewerGroupEnabled: boolean;
    /** 频道用户分组功能开关 */
    channelViewerGroupEnabled: boolean;
    /** 限制仅分组用户允许观看开关 */
    onlyGroupWatchEnabled: boolean;
    /** 不在频道用户分组列表时是否能观看 */
    notInGroupCanWatchEnabled: boolean;
}

/**
 * 一客一码
 */
export declare interface ChannelViewerInviteCustomer {
    /** 是否已通过一客一码邀请，默认 N */
    saleShareEnabled: YN;
    /** 是否为非法的销售码，默认 null */
    saleCodeIllegal: YN | null;
    /** 一客一码--销售邀请的客户id */
    customerId: string | null;
    /** 信息采集设置 */
    collectSetting?: {
        fieldList?: InviteCustomerCollectFieldItem[];
    };
}

/**
 * 邀请观看观众相关信息
 */
export declare interface ChannelViewerInviteWatchInfo {
    /**
     * 邀请员/分销员Id
     * @desc 当邀请员/分销员作为观众时，才会有这个 Id
     */
    salerId: string;
    /**
     * 审核状态
     */
    status: InviteWatchAuditStatus;
    /**
     * 邀请观看的上级邀请员ID
     * @desc 邀请员 A 邀请观众 B 时，观众B的 inviteSalesId 就是邀请员 A 的 inviteWatchSaleId
     */
    inviteSalesId: string;
}

/**
 * 频道观看数据
 */
export declare interface ChannelWatchData {
    /** 点赞数 */
    likes: number;
    /** 页面浏览次数 */
    pageView: number;
}

export declare interface ChannelWatchDurationSetting {
    /**
     * 观看时长开关
     */
    watchDurationEnabled: boolean;
    /**
     * 观看时长类型
     */
    watchDurationType: ChannelWatchDurationType | string;
}

export declare enum ChannelWatchDurationType {
    /** 总观看时长 */
    LivePlayback = "livePlayback",
    /** 仅直播 */
    Live = "live",
    /** 仅回放 */
    Playback = "playback"
}

/**
 * 频道观看页皮肤
 */
export declare enum ChannelWatchPageSkin {
    /**
     * 时尚黑
     */
    Black = "black",
    /**
     * 喜庆红
     */
    Red = "red",
    /**
     * 科技蓝
     */
    Blue = "blue",
    /**
     * 经典白
     */
    White = "white",
    /**
     * 薄荷绿
     */
    Green = "green",
    /**
     * 富贵金
     */
    Golden = "golden",
    /**
     * 清新蓝
     * @version v0.8.0
     */
    Freshblue = "freshblue"
}

/**
 * 频道观看页设置
 */
export declare interface ChannelWatchSetting {
    /** 观看页开关 */
    watchEnabled: boolean;
    /** 移动端观看页开关 */
    mobileWatchEnabled: boolean;
    /** 引导页开关 */
    splashEnabled: boolean;
}

/**
 * 观看页页主题皮肤类型
 */
export declare enum ChannelWatchThemeStyleType {
    /** 纯色 */
    Skin = "skin",
    /** 主题 */
    Theme = "theme"
}

/**
 * 章节节点
 */
export declare interface ChapterItem {
    /** 标题 */
    title: string;
    /** 播放进度 */
    duration: number;
    /** 图片地址 */
    image: string;
}

/**
 * 聊天室 api 请求器
 */
declare class ChatApi extends ApiQuery_2<ChatApiOptions> {
    constructor(options: ApiQueryConfig_2);
    /** 请求处理器 */
    private __chatBeforeRequest;
    /** 响应处理器 */
    private __chatAfterResponse;
    /**
     * 获取聊天室接口入参签名中的时间戳
     */
    private __getChatSignTimestamp;
}

/**
 * 聊天室 api 消息公用类型
 */
export declare interface ChatApiCommonMsgType {
    /** 保利威账号 id */
    accountId: string;
    /** 消息唯一标识 */
    id: string;
    /** 发送时间 */
    time: number;
    /** 用户信息 */
    user: ChatMessageUser;
}

/**
 * 聊天室 api 消息类型 - 自定义消息
 */
export declare interface ChatApiCustomerMsgType extends ChatApiCommonMsgType {
    /** 消息来源 */
    msgSource: 'customerMessage';
    /** 自定义消息内容 */
    content: string;
}

/**
 * 聊天室 api 消息类型 - 自定义消息
 */
export declare interface ChatApiCustomMsgType extends ChatApiCommonMsgType, CustomMessageSocketType {
    /** 消息来源 */
    msgSource: 'custom';
}

/**
 * 聊天室 api 消息类型 - 文件列表
 */
export declare interface ChatApiFileListMsgType extends ChatApiCommonMsgType {
    /** 消息来源 */
    msgSource: 'fileList';
}

/**
 * 聊天室 api 消息类型 - 文件分享
 */
export declare interface ChatApiFileMsgType extends ChatApiCommonMsgType {
    /** 消息来源 */
    msgSource: 'file';
    /** 文件内容（json 字符串） */
    content: string;
}

/**
 * 聊天室 api 消息类型 - 图片内容
 */
export declare interface ChatApiImgMsgContent {
    /** 图片 id，emotion 时为表情 id */
    id: string;
    /** 尺寸 */
    size?: {
        width: number;
        height: number;
    };
    /** 类型 */
    type: 'chatImg' | 'emotion';
    /** 表情图片地址 */
    uploadImgUrl: string;
}

/**
 * 聊天室 api 消息类型 - 图片
 */
export declare interface ChatApiImgMsgType extends ChatApiCommonMsgType {
    /** 消息来源 */
    msgSource: 'chatImg';
    /** 消息内容 */
    content: ChatApiImgMsgContent;
}

/**
 * 聊天室 api 消息类型
 */
export declare type ChatApiMsgType = ChatApiSpeakMsgType | ChatApiImgMsgType | ChatApiRewardMsgType | ChatApiFileMsgType | ChatApiRedpaperMsgType | ChatApiCustomerMsgType | ChatApiCustomMsgType;

/**
 * 聊天室请求选项
 */
declare interface ChatApiOptions extends ApiOptions_2 {
    /** 重写 params 类型，使其必须是 object */
    params?: UniversalParams;
    /** 重写 data 类型，使其必须是 object */
    data?: UniversalParams;
    /** 对 params 进行聊天室签名，默认：false */
    signParams?: boolean;
    /** 对 data 进行聊天室签名，默认：false */
    signData?: boolean;
    /** 插入聊天室 token */
    insertToken?: boolean;
    /** 是否将签名中的时间戳调整为小时级别，默认：false */
    changeTimestamp?: boolean;
    /** response 是否被加密，默认：false */
    responseEncrypted?: boolean;
    /** 是否标准的接口，默认：true */
    isStandard?: boolean;
}

export declare interface ChatApiQuoteCommon {
    /** 用户信息 */
    user?: ChatMessageUser;
    /** 用户昵称 */
    nick: string;
}

/**
 * 聊天室 api 消息中的 quote 字段类型（自定义消息）
 */
export declare interface ChatApiQuoteCustomerType extends ChatApiQuoteCommon {
    /** 消息类型 */
    msgType: 'customerMessage';
    /** 消息内容 */
    content: string;
}

/**
 * 聊天室 api 消息中的 quote 字段类型（图片）
 */
export declare interface ChatApiQuoteImgType extends ChatApiQuoteCommon {
    /** 消息类型 */
    msgType: 'chatImg';
    /** 图片内容 */
    image: {
        /** 图片地址 */
        url: string;
        /** 宽度 */
        width: number;
        /** 高度 */
        height: number;
    };
    /** 用户 id */
    userId: string;
}

/**
 * 聊天室 api 消息中的 quote 字段类型（红包）
 */
export declare interface ChatApiQuoteRedpaperType extends ChatApiQuoteCommon {
    /** 消息类型 */
    msgType: 'redpaper';
    /** 消息内容（红包数据 json） */
    content: string;
}

/**
 * 聊天室 api 消息中的 quote 字段类型（发言）
 */
export declare interface ChatApiQuoteSpeakType extends ChatApiQuoteCommon {
    /** 消息类型 */
    msgType?: null;
    /** 消息内容 */
    content: string;
    /** 用户 id */
    userId: string;
}

/**
 * 聊天室 api 消息中的 quote 字段类型
 */
export declare type ChatApiQuoteType = ChatApiQuoteSpeakType | ChatApiQuoteImgType | ChatApiQuoteRedpaperType | ChatApiQuoteCustomerType;

/**
 * 聊天室 api 消息类型 - 红包
 */
export declare interface ChatApiRedpaperMsgType extends ChatApiCommonMsgType, ChatMsgRedpaperData {
    /** 消息来源 */
    msgSource: 'redpaper';
    /** 用户标签 */
    userTags?: string[];
}

/**
 * 聊天室 api 重放消息类型 - 答题卡消息类型
 */
declare interface ChatApiReplayAnswerCardMsgType extends ChatApiReplayCommonMsgType, IarReplayAnswerCardMsg {
    msgType: 'testQuestion';
}

/**
 * 聊天室 api 重放消息类型 - 签到消息类型
 */
declare interface ChatApiReplayCheckInMsgType extends ChatApiReplayCommonMsgType, IarReplayCheckInMsg {
    msgType: 'signin';
}

/**
 * 聊天室 api 重放消息公用类型
 */
declare interface ChatApiReplayCommonMsgType {
    /** 保利威账号 id */
    accountId: string;
    /** 消息唯一标识 */
    id: string;
    /** 发送时间 */
    time: number;
    /** ChatMessageUser */
    user: ChatMessageUser;
    /** 回复字段(json 字符串) ChatApiQuoteType */
    quote: string;
    /** 相对时间戳 */
    relativeTime: number;
}

/**
 * 聊天室 api 重放消息类型 - 自定义消息
 */
declare interface ChatApiReplayCustomerMsgType extends ChatApiReplayCommonMsgType {
    /** 消息来源 */
    msgType: 'customerMessage';
    /** 自定义消息内容 */
    content: string;
}

/**
 * 聊天室 api 重放消息类型 - 文件分享
 */
declare interface ChatApiReplayFileMsgType extends ChatApiReplayCommonMsgType {
    /** 消息来源 */
    msgType: 'file';
    /** 文件内容（json 字符串） */
    content: string;
}

/**
 * 聊天室 api 重放消息类型 - 图片
 */
declare interface ChatApiReplayImgMsgType extends ChatApiReplayCommonMsgType {
    /** 消息来源 */
    msgType: 'chatImg';
    /** 消息内容 （json 字符串）ChatApiImgMsgContent */
    content: string;
}

/**
 * 聊天室 api 重放消息类型
 */
declare type ChatApiReplayMsgType = ChatApiReplaySpeakMsgType | ChatApiReplayImgMsgType | ChatApiReplayRewardMsgType | ChatApiReplayFileMsgType | ChatApiReplayRedpaperMsgType | ChatApiReplayCustomerMsgType | ChatApiReplaySpeakTopMsgType | ChatApiReplayPushCardMsgType | ChatApiReplayCheckInMsgType | ChatApiReplayAnswerCardMsgType | ChatApiReplayQuestionnaireMsgType;

/**
 * 聊天室 api 重放消息类型 - 卡片推送消息
 */
declare interface ChatApiReplayPushCardMsgType extends ChatApiReplayCommonMsgType, IarReplayPushCardMsg {
    msgType: 'newsPushCard';
}

/**
 * 聊天室 api 重放消息类型 - 问卷消息类型
 */
declare interface ChatApiReplayQuestionnaireMsgType extends ChatApiReplayCommonMsgType, IarReplayQuestionnaireMsg {
    msgType: 'questionnaire';
}

/**
 * 聊天室 api 重放消息类型 - 红包
 */
declare interface ChatApiReplayRedpaperMsgType extends ChatApiReplayCommonMsgType {
    /** （json 字符串）ChatMsgRedpaperData */
    content: string;
    /** 消息来源 */
    msgType: 'redpaper';
}

/**
 * 聊天室 api 重放消息类型 - 打赏
 */
declare interface ChatApiReplayRewardMsgType extends ChatApiReplayCommonMsgType {
    /** 消息来源 */
    msgType: 'reward';
    /** 打赏内容 （json 字符串） ChatApiRewardMsgContent */
    content: string;
}

/**
 * 聊天室 api 重放消息类型 - 发言
 */
declare interface ChatApiReplaySpeakMsgType extends ChatApiReplayCommonMsgType {
    /** 消息来源 */
    msgType: null;
    /** 发言内容 */
    content: string;
    /** 是否超长 */
    overLen?: boolean;
}

/**
 * 聊天室 api 重放消息类型 - 评论上墙
 */
declare interface ChatApiReplaySpeakTopMsgType extends ChatApiReplayCommonMsgType {
    msgType: 'speakTop';
    /** 评论上墙内容 */
    content: string;
    /** 评论上墙昵称 */
    nick: string;
    /** 评论上墙头像 */
    pic: string;
    topActor: string;
}

declare class ChatApiRequest extends PolyvRequest<ChatApiRequestOptions> {
    constructor(interactionCore: InteractionCore);
}

declare interface ChatApiRequestOptions extends RequestOptions {
    /**
     * 插入频道号
     * @default true
     */
    appendChannelId?: boolean;
    /**
     * 插入用户 userId
     * @default true
     */
    appendUserId?: boolean;
    /**
     * 使用 header 方式传递 token
     * @default false
     */
    tokenInHeader?: boolean;
}

/**
 * 聊天室 api 消息类型 - 打赏内容
 */
export declare interface ChatApiRewardMsgContent {
    /** 打赏道具图片地址，为空则表示现金打赏 */
    gimg: string;
    /** 打赏数量 */
    goodNum: number;
    /** 打赏道具名称或打赏金额 */
    rewardContent: string;
}

/**
 * 聊天室 api 消息类型 - 打赏
 */
export declare interface ChatApiRewardMsgType extends ChatApiCommonMsgType {
    /** 消息来源 */
    msgSource: 'reward';
    /** 打赏内容 */
    content: ChatApiRewardMsgContent;
}

/**
 * 聊天室 api 消息类型 - 发言
 */
export declare interface ChatApiSpeakMsgType extends ChatApiCommonMsgType {
    /** 消息来源 */
    msgSource?: undefined;
    /** 发言内容 */
    content: string;
    /** 回复字段 */
    quote?: ChatApiQuoteType;
    /** 是否超长 */
    overLen?: boolean;
}

/**
 * 聊天室连接失败原因
 */
export declare enum ChatConnectFailReason {
    /** 令牌过期 */
    TokenExpired = "TokenExpired",
    /** socket 连接失败 */
    SocketConnectError = "SocketConnectError",
    /** socket 连接超时 */
    SocketConnectTimeout = "SocketConnectTimeout",
    /** socket 重连中 */
    SocketReconnectAttempt = "SocketReconnectAttempt"
}

export declare interface ChatCoreConfig {
    /** 获取当前的 socket 配置，并返回修改后的配置 */
    getPlvSocketConfig?: (config: PlvSocketConfig) => PlvSocketConfig;
}

/**
 * 聊天室模块事件
 * @eventenum {@link ChatEventsRelations}
 */
export declare enum ChatEvents {
    /**
     * V2 的聊天室 SDK 安装完成回调
     */
    ChatSdkV2Setuped = "ChatSdkV2Setuped",
    /**
     * 聊天室信息修改
     *
     * 聊天室模块会保存基本的聊天室状态信息，通过该事件监听聊天室状态改变
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.ChatInfoChange, (evt) => {
     *   const chatInfo = evt.chatInfo;
     *   console.log('聊天室是否已关闭', chatInfo.chatRoomIsClosed);
     * });
     * ```
     */
    ChatInfoChange = "ChatInfoChange",
    /**
     * 聊天室重连成功事件
     * @version v0.3.2
     * @description 当聊天室断连重连成功时触发该事件
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.ChatReconnectSuccess, () => {
     *   console.info("重连成功！")
     * });
     * ```
     */
    ChatReconnectSuccess = "ChatReconnectSuccess",
    /**
     * 聊天室连接失败事件
     * @description 当断网或其他因素导致聊天室链接失败时触发该事件
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.ChatConnectFail, (data) => {
     *   confirm({
     *     message: '聊天室连接失败，无法与其他人互动，立即刷新重试？',
     *     onConfirm: () => location.reload(),
     *   });
     * });
     * ```
     */
    ChatConnectFail = "ChatConnectFail",
    /**
     * 聊天消息事件
     * @description 当收到聊天消息后触发该事件
     * @example
     * ```js
     * // 聊天消息列表
     * const chatMsgList: ChatMsgType[] = [];
     *
     * // 聊天消息事件
     * watchCore.chat.eventEmitter.on(ChatEvents.ChatMessage, (data) => {
     * // 插入到聊天消息列表
     *   chatMsgList.push(data.chatMsg);
     *   // 渲染聊天消息...
     * });
     * ```
     */
    ChatMessage = "ChatMessage",
    /**
     * 替换聊天消息事件
     *
     * 当调用 `sendSpeakMsg` 等发送消息方法中，发送到服务端前就会回调 `ChatEvents.ChatMessage` 事件，此时消息 id 为本地 id，发送到服务端并回调了消息 id 后触发该事件，收到该消息后根据 id 更新成新的消息对象和渲染信息。
     *
     * 另外发送图片消息如果服务端检测到违规图后也通过该事件更新。
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.ReplaceChatMessage, (data) => {
     *   // 需要被替换的消息 id
     *   const replaceId = data.id;
     *   // 新的消息对象
     *   const chatMsg = data.chatMsg;
     *
     *   const index = chatMsgList.findIndex((item) => item.id === replaceId);
     *   if (index !== -1) {
     *     chatMsgList[index] = chatMsg;
     *   }
     *   // 将视图的消息节点替换...
     * });
     * ```
     */
    ReplaceChatMessage = "ReplaceChatMessage",
    /**
     * 点赞事件
     * @description 通过该事件监听用户的点赞事件
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.ChatLike, (data) => {
     *   console.log('实时点赞数：', data.realtimeLikes);
     *   console.log('该观众的点赞次数', data.count);
     *   console.log('点赞的观众 id', data.userId);
     *   console.log('点赞的观众昵称', data.nick);
     * });
     * ```
     */
    ChatLike = "ChatLike",
    /**
     * 点赞数修改事件
     * @description 通过该事件监听点赞数改变事件，回调后更新页面的点赞数显示。
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.ChatLikeCountChange, (data) => {
     *   console.log('实时点赞数：', data.realtimeLikes);
     * });
     * ```
     */
    ChatLikeCountChange = "ChatLikeCountChange",
    /**
     * 情绪反馈事件
     * @description 通过该事件监听用户的情绪反馈事件
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.ChatEmotionalFeedback, (data) => {
     *   console.log('类型：', data.type); // EmotionalFeedbackType
     *   console.log('数量：', data.count);
     * });
     * ```
     */
    ChatEmotionalFeedback = "ChatEmotionalFeedback",
    /**
     * 聊天室用户登录事件
     * @description 有观众进入聊天室后触发该事件
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.ChatUserLogin, (data) => {
     *   const user = data.user;
     *   toast.info(`欢迎 ${user.nick} 进入`);
     * });
     * ```
     */
    ChatUserLogin = "ChatUserLogin",
    /**
     * 聊天室用户登出事件
     * @description 当观众退出聊天室后触发该事件
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.ChatUserLogout, (data) => {
     *   const userId = data.userId;
     *   console.log('退出的用户 id', userId);
     * });
     * ```
     */
    ChatUserLogout = "ChatUserLogout",
    /**
     * 当前用户重复登录事件
     * @description 当用户重复登录聊天室时触发该事件，触发后当前页面将无法接收到任何聊天室消息
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.CurrentUserRelogin, (data) => {
     *   toast.errot('您已在其他地方登录，3 秒后将推出该页面');
     *   setTimeout(() => {
     *     location.replace('跳出到页面地址');
     *   }, 3000);
     * });
     * ```
     */
    CurrentUserRelogin = "CurrentUserRelogin",
    /**
     * 清空聊天室事件
     * @description 管理员清空聊天历史记录后触发该事件
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.ClearMsgHistory, () => {
     *   console.log('管理员清空历史记录，todo 清空聊天记录列表');
     * });
     * ```
     */
    ClearMsgHistory = "ClearMsgHistory",
    /**
     * 删除某条消息事件
     * @description 管理员删除某条历史消息后触发该事件
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.RemoveChatMsg, (data) => {
     *   console.log('管理员删除历史消息，删除的消息 id：', data.id);
     * });
     * ```
     */
    RemoveChatMsg = "RemoveChatMsg",
    /**
     * 聊天室关闭事件
     * @description 讲师或管理员关闭聊天室后触发该事件
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.CloseChatRoom, () => {
     *   watchCore.chat.sendSystemMsg('聊天室已关闭');
     * });
     * ```
     */
    CloseChatRoom = "CloseChatRoom",
    /**
     * 聊天室开启事件
     * @description 讲师或管理员开启聊天室后触发该事件
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.CloseChatRoom, () => {
     *   watchCore.chat.sendSystemMsg('聊天室已打开');
     * });
     * ```
     */
    OpenChatRoom = "OpenChatRoom",
    /**
     * 在线人数改变事件
     * @description 当观众上线/下线时，会回调该事件用于实时获取在线人数
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.OnlineUserCountChange, (data) => {
     *   console.log('在线人数改变：', data.onlineUserCount);
     * });
     * ```
     */
    OnlineUserCountChange = "OnlineUserCountChange",
    /**
     * 在线用户列表改变事件
     * @version v1.8.0
     * @description 当开始轮询在线用户列表时，会回调该事件\
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.OnlineUserListChange, (data) => {
     *   console.log('在线用户列表：', data.userlist);
     * });
     * ```
     */
    OnlineUserListChange = "OnlineUserListChange",
    /**
     * 聊天消息重放-重新加载
     * @version v0.3.0
     * @description 通知外部重新加载聊天重放的数据
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.ChatMsgReplayReload, () => {
     *   // initChatMsgRender
     *   console.log('需要重新加载聊天重放数据渲染表格');
     * });
     * ```
     */
    ChatMsgReplayReload = "ChatMsgReplayReload",
    /**
     * 聊天消息重放状态
     * @version v0.3.0
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.ChatMsgReplayStatusChange, (params) => {
     *   console.log('聊天重放状态变更：', params.status);
     * });
     * ```
     */
    ChatMsgReplayStatusChange = "ChatMsgReplayStatusChange",
    /**
     * 聊天消息重放中
     * @version v0.3.0
     * @internal
     * @ignore
     */
    ChatMsgReplaying = "ChatMsgReplaying",
    /**
     * 聊天消息重放的当前列表
     * @version v2.0.0
     * @internal
     * @ignore
     */
    ChatMsgReplayCurrentDetailList = "ChatMsgReplayCurrentDetailList",
    /**
     * 聊天消息重放的回放时间点
     * @version v2.0.0
     * @internal
     * @ignore
     */
    ChatMsgReplayTimeUpdate = "ChatMsgReplayTimeUpdate",
    /**
     * 当前观众发言事件
     * @internal
     * @ignore
     */
    SelfSpeak = "SelfSpeak",
    /**
     * 超出直播间最大在线人数
     * @version v0.5.1
     */
    OverMaxOnlineCount = "OverMaxOnlineCount",
    /**
     * 白名单移除用户
     * @version v1.3.0
     */
    WhiteListRemoveUser = "WhiteListRemoveUser",
    /**
     * 评论上墙事件
     * @version v1.5.0
     */
    SpeakToTop = "SpeakToTop",
    /**
     * 评论取消上墙事件
     * @version v1.5.0
     */
    SpeakCancelTop = "SpeakCancelTop",
    /**
     * 超出频道登录限制事件
     * @version v2.13.0
     */
    OverLoginLimit = "OverLoginLimit"
}

/**
 * 聊天室模块事件回调参数配置
 */
export declare type ChatEventsRelations = {
    [ChatEvents.ChatInfoChange]: {
        /**
         * 聊天室信息
         */
        chatInfo: ChatModuleInfo;
    };
    [ChatEvents.ChatConnectFail]: {
        /**
         * 连接失败原因
         */
        reason: ChatConnectFailReason;
    };
    [ChatEvents.ChatMessage]: {
        /**
         * 聊天消息对象
         */
        chatMsg: ChatMsgType;
        /**
         * 是否为聊天重放消息
         * @version v2.7.0
         * @default undefined|false
         */
        isChatReplayMsg?: boolean;
    };
    [ChatEvents.ReplaceChatMessage]: {
        /**
         * 替换的消息 id
         */
        id: string;
        /**
         * 新的消息对象
         */
        chatMsg: ChatMsgType;
    };
    [ChatEvents.ChatLike]: {
        /**
         * 点赞数
         */
        count: number;
        /**
         * 实时点赞数
         */
        realtimeLikes: number;
        /**
         * 用户 id
         */
        userId: string;
        /**
         * 用户昵称
         */
        nick: string;
        /**
         * 是否自己点赞
         */
        isSelf: boolean;
    };
    [ChatEvents.ChatLikeCountChange]: {
        /**
         * 实时点赞数
         */
        realtimeLikes: number;
    };
    [ChatEvents.ChatEmotionalFeedback]: {
        /**
         * 情绪类型
         */
        type: EmotionalFeedbackType;
        /**
         * 数量
         */
        count: number;
    };
    [ChatEvents.ChatUserLogin]: {
        /**
         * 用户信息
         */
        user: ChatMessageUser;
    };
    [ChatEvents.ChatUserLogout]: {
        /**
         * 用户 userId
         */
        userId: string;
    };
    [ChatEvents.CurrentUserRelogin]: {
        /**
         * 错误来源
         * @version v0.5.1
         */
        causeBy: string;
    };
    [ChatEvents.RemoveChatMsg]: {
        /**
         * 删除的消息 id
         */
        id: string;
    };
    [ChatEvents.OnlineUserCountChange]: {
        /**
         * 实时在线人数
         */
        onlineUserCount: number;
    };
    [ChatEvents.ChatMsgReplaying]: {
        /**
         * 消息对象
         */
        chatMsg: ChatReplayMsgType;
    };
    [ChatEvents.ChatMsgReplayStatusChange]: {
        /**
         * 重放状态
         */
        status: ChatMsgReplayStatus;
    };
    [ChatEvents.SelfSpeak]: {
        /**
         * 发言消息对象
         */
        chatMsg: ChatMsgSpeakType;
        /**
         * 只在本地回调
         * @version v1.0.0
         */
        isOnlyLocalMsg: boolean;
    };
    /**
     * 评论上墙
     */
    [ChatEvents.SpeakToTop]: ChatMsgSpeakTopType;
    /**
     * 取消上墙
     */
    [ChatEvents.SpeakCancelTop]: {
        id: string;
    } | undefined;
    /**
     * 在线用户列表
     */
    [ChatEvents.OnlineUserListChange]: UserListResult;
    /**
     * 聊天消息重放-重新加载
     */
    [ChatEvents.ChatMsgReplayReload]: {
        /**
         * @version v2.0.0
         */
        seconds?: number;
    };
    /**
     * 聊天消息重放的当前列表
     */
    [ChatEvents.ChatMsgReplayCurrentDetailList]: {
        /**
         * 当前重放的消息列表
         */
        msgList: ChatReplayMsgType[];
    };
    [ChatEvents.ChatMsgReplayTimeUpdate]: {
        /**
         * 当前回放的时间点(单位：秒)
         */
        currentReplayTime: number;
    };
    [ChatEvents.OverLoginLimit]?: {
        /**
         * 刚开始直播时, 由于超过频道限制人数所触发的RELOGIN
         */
        isStartLiveOverLogin?: boolean;
    };
};

/**
 * @file 通过聊天室接口获取回来的聊天室消息类型
 */

export declare interface ChatListResponse {
    page: number;
    size: number;
    totalCount: number;
    totalPage: number;
}

/**
 * 聊天消息布局
 */
export declare enum ChatMessageLayout {
    /** 紧凑 */
    Compact = "compact",
    /** 宽松 */
    Loose = "loose"
}

/**
 * @file 聊天室中跟用户相关的消息类型
 */

/**
 * 聊天室消息中的用户信息
 */
export declare interface ChatMessageUser<T extends ChatUserType = ChatUserType> {
    /**
     * 用户 id
     * @description 系统消息或自定义消息中的 userId 固定为 system
     */
    userId: string;
    /**
     * 昵称
     */
    nick: string;
    /**
     * 头像
     */
    pic?: string;
    /**
     * 身份
     */
    userType: T;
    /**
     * 头衔
     */
    actor?: string;
    /**
     * 是否被禁言
     */
    banned?: boolean;
    /**
     * 用户 ip
     */
    clientIp?: string;
    /**
     * 登录的 userId
     * @internal
     * @ignore
     */
    loginId?: string;
    /**
     * 标签
     */
    label?: {
        /** 提问区标签 */
        question: string[];
    };
}

/**
 * 聊天室信息
 */
export declare interface ChatModuleInfo {
    /**
     * 聊天室 token
     * @internal
     * @ignore
     */
    chatToken?: string;
    /**
     * 房间号
     * @internal
     * @ignore
     */
    roomId: string;
    /**
     * 用户 ip
     * @internal
     * @ignore
     */
    viewerIP: string;
    /**
     * 聊天室是否被退出
     */
    chatExited: boolean;
    /**
     * 聊天室是否已关闭
     */
    chatRoomIsClosed: boolean;
    /**
     * 是否被踢出
     */
    isKicked: boolean;
    /**
     * 是否被禁言
     */
    isShield: boolean;
}

/**
 * 聊天室消息公用基础类型
 */
export declare interface ChatMsgCommonBasicType<S extends ChatMsgSource> {
    /** 消息唯一标识 */
    id: string;
    /** 消息来源 */
    msgSource: S;
    /** 消息时间 */
    time: number;
}

/**
 * 聊天室消息公用类型
 */
export declare interface ChatMsgCommonType<S extends ChatMsgSource> extends ChatMsgCommonBasicType<S> {
    /** 用户信息 */
    user: ChatMessageUser;
}

/**
 * 聊天室消息类型 - 自定义消息(服务端)
 * @source {@link ChatMsgSource.CustomerMessage}
 */
export declare interface ChatMsgCustomerMessageType extends ChatMsgCommonType<ChatMsgSource.CustomerMessage> {
    /** 消息内容 */
    content: string;
}

/**
 * 聊天室消息类型 - 自定义消息(客户端)
 * @source {@link ChatMsgSource.CustomMessage}
 */
export declare interface ChatMsgCustomMessageType extends ChatMsgCommonType<ChatMsgSource.CustomMessage>, CustomMessageSocketType {
}

/**
 * 聊天室消息类型 - 特效消息
 * @source {@link ChatMsgSource.Effect}
 */
export declare interface ChatMsgEffectType extends ChatMsgCommonBasicType<ChatMsgSource.Effect> {
    data: unknown;
}

/**
 * 聊天室消息类型 - 表情
 * @source {@link ChatMsgSource.Emotion}
 */
export declare interface ChatMsgEmotionType extends ChatMsgCommonType<ChatMsgSource.Emotion> {
    /** 表情 id */
    emotionId?: string;
    /** 表情图片地址 */
    emotionUrl: string;
    /** 图片尺寸，socket 消息中的没有尺寸返回 */
    size?: {
        width: number;
        height: number;
    };
    /** 是否本地发送的消息 */
    isLocal?: boolean;
    /**
     * 是否已经发送完成
     * @version v1.2.0
     */
    isSended?: boolean;
    /**
     * 是否发送失败
     * @version v1.3.0
     */
    isSendFailed?: boolean;
}

/**
 * 聊天室消息类型 - 文件分享
 * @source {@link ChatMsgSource.File}
 */
export declare interface ChatMsgFileType extends ChatMsgCommonType<ChatMsgSource.File> {
    /** 文件下载地址 */
    fileUrl: string;
    /** 文件名称 */
    fileName: string;
}

/**
 * 聊天室消息类型 - 答题卡
 * @source {@link ChatMsgSource.IarAnswerCard}
 */
export declare interface ChatMsgIarAnswerCardMessageType extends ChatMsgCommonType<ChatMsgSource.IarAnswerCard> {
    replayData: IarReplayAnswerCardMsg;
    relativeTime: number;
}

/**
 * 聊天室消息类型 - 签到
 * @source {@link ChatMsgSource.IarCheckIn}
 */
export declare interface ChatMsgIarCheckInMessageType extends ChatMsgCommonType<ChatMsgSource.IarCheckIn> {
    replayData: IarReplayCheckInMsg;
    relativeTime: number;
}

/**
 * 聊天室消息类型 - 卡片推送
 * @source {@link ChatMsgSource.IarPushCard}
 */
export declare interface ChatMsgIarPushCardMessageType extends ChatMsgCommonType<ChatMsgSource.IarPushCard> {
    replayData: IarReplayPushCardMsg;
    relativeTime: number;
}

/**
 * 聊天室消息类型 - 问卷
 * @source {@link ChatMsgSource.IarQuestionnaire}
 */
export declare interface ChatMsgIarQuestionnaireMessageType extends ChatMsgCommonType<ChatMsgSource.IarQuestionnaire> {
    replayData: IarReplayQuestionnaireMsg;
    relativeTime: number;
}

/**
 * 聊天室消息类型 - 图片
 * @source {@link ChatMsgSource.Image}
 */
export declare interface ChatMsgImageType extends ChatMsgCommonType<ChatMsgSource.Image> {
    /** 图片 id */
    imageId: string;
    /** 图片地址 */
    imageUrl: string;
    /** 图片尺寸 */
    size?: {
        width: number;
        height: number;
    };
    /** 是否本地发送的消息 */
    isLocal?: boolean;
    /** 是否已经发送完成 */
    isSended?: boolean;
    /** 本地发送消息的图片地址 */
    localImageUrl?: string;
    /** 是否违规 */
    isIllegal?: boolean;
    /**
     * 是否发送失败
     * @version v1.2.0
     * */
    isSendFailed?: boolean;
}

/**
 * 聊天室单个信息的发送状态
 */
export declare enum ChatMsgItemSendStatus {
    /** loading的状态 */
    Loading = "loading",
    /** 发送失败的状态 */
    Fail = "fail",
    /** 默认状态，发送成功也是显示默认状态 */
    Default = "default"
}

/**
 * 聊天室消息类型 - 课堂激励点赞消息
 * @source {@link ChatMsgSource.MotivationLike}
 */
export declare interface ChatMsgMotivationLikeType extends Omit<MotivationLikeItem, 'times'>, ChatMsgCommonBasicType<ChatMsgSource.MotivationLike> {
}

declare interface ChatMsgQuoteCommonType {
    /** 用户昵称 */
    nick: string;
    /** 被回复的用户信息 */
    user?: ChatMessageUser;
}

/**
 * 聊天室回复类型（自定义消息）
 */
declare interface ChatMsgQuoteCustomerType extends ChatMsgQuoteCommonType {
    /** 消息来源 */
    msgSource: ChatMsgSource.CustomerMessage;
    /** 自定义消息内容 */
    content: string;
}

/**
 * 聊天室回复类型（图片）
 */
declare interface ChatMsgQuoteImageType extends ChatMsgQuoteCommonType {
    /** 消息来源 */
    msgSource: ChatMsgSource.Image;
    /** 图片地址 */
    imageUrl: string;
    /** 图片尺寸 */
    size?: {
        width: number;
        height: number;
    };
    /** 用户 id */
    userId: string;
}

/**
 * 聊天消息中的引用回复消息来源
 */
export declare type ChatMsgQuoteOriginType = ChatMsgSpeakType | ChatMsgImageType | ChatMsgRedpaperType | ChatMsgCustomerMessageType;

/**
 * 聊天室回复类型（红包）
 */
export declare interface ChatMsgQuoteRedpaperType extends ChatMsgRedpaperData, ChatMsgQuoteCommonType {
    /** 消息来源 */
    msgSource: ChatMsgSource.Redpaper;
}

/**
 * 聊天室回复类型（普通文本）
 */
declare interface ChatMsgQuoteSpeakType extends ChatMsgQuoteCommonType {
    /** 消息来源 */
    msgSource: ChatMsgSource.Speak;
    /** 回复文本内容 */
    content: string;
    /** 用户 id */
    userId: string;
}

/**
 * 聊天室消息中回复字段类型
 */
export declare type ChatMsgQuoteType = ChatMsgQuoteSpeakType | ChatMsgQuoteImageType | ChatMsgQuoteRedpaperType | ChatMsgQuoteCustomerType;

/**
 * 聊天室红包数据类型
 */
declare interface ChatMsgRedpaperData {
    /** 红包缓存 id */
    redCacheId: string;
    /** 红包 id */
    redpackId: string;
    /** 红包总金额 */
    totalAmount: number;
    /** 红包数量 */
    number: number;
    /** 祝福语 */
    content: string;
    /** 红包类型 */
    type: RedpackType;
}

/**
 * 聊天室消息类型 - 红包领取
 * @source {@link ChatMsgSource.RedpaperReceive}
 */
export declare interface ChatMsgRedpaperReceiveType extends ChatMsgCommonBasicType<ChatMsgSource.RedpaperReceive> {
    /** 领取用户的昵称 */
    nick: string;
    /** 红包类型 */
    type: RedpackType;
    /** 是否已领取完毕 */
    isOver: boolean;
}

/**
 * 聊天室消息类型 - 红包
 * @source {@link ChatMsgSource.Redpaper}
 */
export declare interface ChatMsgRedpaperType extends ChatMsgCommonType<ChatMsgSource.Redpaper>, ChatMsgRedpaperData {
    /**
     * 红包的用户标签
     */
    userLabels?: number[];
}

/**
 * 聊天重放插件类型
 * @desc 只要支持以下方法就行，不约束外部使用哪个库
 */
export declare interface ChatMsgReplayCachePluginType extends UniversalParams {
    /**
     * 获取数据项
     */
    getItem<T>(key: string, callback?: (err: unknown, value: T | null) => void): Promise<T | null>;
    /**
     * 设置数据项
     */
    setItem<T>(key: string, value: T, callback?: (err: unknown, value: T) => void): Promise<T>;
    /**
     * 移除数据项
     */
    removeItem(key: string, callback?: (err: unknown) => void): Promise<void>;
    /**
     * 迭代数据项
     */
    iterate<T, U>(iteratee: (value: T, key: string, iterationNumber: number) => U, callback?: (err: unknown, result: U) => void): Promise<U>;
}

/**
 * @file 经过过滤后对外提供的聊天室消息类型
 */

/** 聊天重放的消息才会有公共字段 */
export declare interface ChatMsgReplayField {
    /** 相对时间戳 */
    relativeTime: number;
}

/** 聊天消息重放状态 */
export declare enum ChatMsgReplayStatus {
    /** 等待重放消息生成中 */
    Wait = "Wait",
    /** 初始化失败 */
    InitFail = "InitFail",
    /** 初始化成功 */
    InitSuccess = "InitSuccess",
    /** 请求历史数据失败 */
    RequestHistoryFail = "RequestHistoryFail"
}

/**
 * 聊天室消息类型 - 打赏
 * @source {@link ChatMsgSource.Reward}
 */
export declare interface ChatMsgRewardType extends ChatMsgCommonType<ChatMsgSource.Reward> {
    /** 打赏礼物图片 */
    gimg: string;
    /** 打赏礼物动效 */
    dynamicFile?: string;
    /** 打赏数量 */
    goodNum: number;
    /** 打赏类型 */
    donateType: DonateType;
    /** 打赏道具名称或现金打赏金额 */
    rewardContent: string;
    /** 是否自己的打赏 */
    isSelf: boolean;
    /** 是否免费礼物 */
    isFree: boolean;
    /** 是否本地发送的消息 */
    isLocal?: boolean;
}

/**
 * 聊天室 sdk 消息过滤器
 */
declare class ChatMsgSdkFilter {
    private __chatModule;
    private __watchCore;
    constructor(__chatModule: PlvChatModule, __watchCore: PolyvWatchCore);
    private __filterMsgUser;
    /**
     * 将聊天消息过滤成回复数据
     * @param chatMsg 聊天消息
     */
    filterMsgOriginQuote(chatMsg: ChatMsgQuoteOriginType): ChatMsgQuoteType | undefined;
    /**
     * 过滤 sdk 消息中的 quote 字段
     * @param quote 回复字段
     */
    filterSdkQuote(quote: ChatSdkQuoteType | undefined): ChatMsgQuoteType | undefined;
    /**
     * 过滤发言 sdk 消息
     * @param sdkMsg
     */
    filterSpeakSdkMsg(sdkMsg: ChatSdkSpeakMsgType): ChatMsgSpeakType | ChatMsgFileType | ChatMsgImageType;
    /**
     * 过滤发言（文件）sdk 消息
     * @param sdkMsg
     */
    filterFileSdkMsg(sdkMsg: ChatSdkSpeakFileMsgType): ChatMsgFileType | ChatMsgImageType;
    /**
     * 过滤图片 sdk 消息
     * @param sdkMsg
     */
    filterChatImgSdkMsg(sdkMsg: ChatSdkImgMsgType): ChatMsgImageType;
    /**
     * 过滤图片 sdk 消息
     * @param sdkMsg
     */
    filterEmotionSdkMsg(sdkMsg: ChatSdkEmotionMsgType): ChatMsgEmotionType;
    /**
     * 过滤打赏 sdk 消息
     * @param sdkMsg
     */
    filterRewardSdkMsg(sdkMsg: ChatSdkRewardMsgType): ChatMsgRewardType;
    /**
     * 过滤红包 sdk 消息
     * @param sdkMsg
     */
    filterRedpaperSdkMsg(sdkMsg: ChatSdkRedpaperMsgType): ChatMsgRedpaperType;
    /**
     * 过滤红包领取 sdk 消息
     * @param sdkMsg
     */
    filterRedpaperReceiveSdkMsg(sdkMsg: ChatSdkRedpaperResultMsgType): ChatMsgRedpaperReceiveType;
    /**
     * 过滤自定义 sdk 消息（服务端）
     */
    filterCustomerSdkMsg(sdkMsg: ChatSdkCustomerMsgType): ChatMsgCustomerMessageType;
    /**
     * 过滤自定义 sdk 消息（客户端）
     */
    filterCustomSdkMsg(sdkMsg: ChatSdkCustomMsgType): ChatMsgCustomMessageType;
}

/**
 * 聊天消息来源
 *
 * 通过聊天室消息事件 `ChatEvents.ChatMessage`、聊天历史记录 Api `getChatHistory` 等获取的聊天消息类型均为 ChatMsgSource 类型
 * 所有消息数据都有对应的消息来源 `msgSource` 字段，该字段为 `ChatMsgSource` 枚举，开发者可根据该字段显示相应的消息样式。
 */
export declare enum ChatMsgSource {
    /**
     * 发言消息
     * @msgType {@link ChatMsgSpeakType}
     * @service ✓
     */
    Speak = "speak",
    /**
     * 图片消息
     * @msgType {@link ChatMsgImageType}
     * @service ✓
     */
    Image = "image",
    /**
     * 表情图片消息
     * @msgType {@link ChatMsgEmotionType}
     * @service ✓
     */
    Emotion = "emotion",
    /**
     * 打赏消息
     * @msgType {@link ChatMsgRewardType}
     * @service ✓
     */
    Reward = "reward",
    /**
     * 文件分享消息
     * @msgType {@link ChatMsgFileType}
     * @service ✓
     */
    File = "file",
    /**
     * 红包消息
     * @msgType {@link ChatMsgRedpaperType}
     * @service ✓
     */
    Redpaper = "redpaper",
    /**
     * 红包领取消息
     * @msgType {@link ChatMsgRedpaperReceiveType}
     * @service ×
     */
    RedpaperReceive = "redpaperReceive",
    /**
     * 自定义消息(服务端)
     * @msgType {@link ChatMsgCustomerMessageType}
     * @service ✓
     */
    CustomerMessage = "customerMessage",
    /**
     * 自定义消息(客户端)
     * @msgType {@link ChatMsgCustomMessageType}
     * @service x
     */
    CustomMessage = "customMessage",
    /**
     * 系统消息
     * @msgType {@link ChatMsgSystemType}
     * @service ×
     */
    System = "system",
    /**
     * 课堂激励点赞消息
     * @version v0.10.0
     * @msgType {@link ChatMsgMotivationLikeType}
     * @warn 目前不会存储到历史消息中
     * @service ×
     */
    MotivationLike = "motivationLike",
    /**
     * 评论上墙
     * @version v1.5.0
     */
    SpeakTop = "speakTop",
    /**
     * @version v2.0.0
     */
    SpeakCancelTop = "speakCancelTop",
    /**
     * 消息特效
     * @version v2.0.0
     * @desc 类似自定义消息
     * @warn 目前不会存储到历史消息中
     * @service ×
     */
    Effect = "effect",
    /**
     * 卡片推送消息
     * @desc 当前仅聊天重放会使用
     * @version v2.0.0
     * @msgType {@link ChatMsgIarPushCardMessageType}
     * @internal
     * @service ✓
     */
    IarPushCard = "iarPushCard",
    /**
     * 签到消息
     * @desc 当前仅聊天重放会使用 {@link ChatApiReplayCheckInMsgType}
     * @version v2.1.0
     * @msgType {@link ChatMsgIarCheckInMessageType}
     * @service ✓
     */
    IarCheckIn = "iarCheckIn",
    /**
     * 答题卡消息
     * @desc 当前仅聊天重放会使用 {@link ChatApiReplayAnswerCardMsgType}
     * @version v2.1.0
     * @msgType {@link ChatMsgIarAnswerCardMessageType}
     * @service ✓
     */
    IarAnswerCard = "iarAnswerCard",
    /**
     * 问卷消息
     * @desc 当前仅聊天重放会使用 {@link ChatApiReplayQuestionnaireMsgType}
     * @version v2.1.0
     * @msgType {@link ChatMsgIarQuestionnaireMessageType}
     * @service ✓
     */
    IarQuestionnaire = "iarQuestionnaire",
    /**
     * 未知的消息来源
     * @version v2.0.0
     * @warn 只用作 sdk 内部的兜底处理
     * @service ×
     */
    Unknown = "unknown"
}

/**
 * 聊天室消息类型 - 评论上墙
 * @warn 只有聊天重放才会用到该类型，但不会通过 ChatMessage 触发出去，而是使用 {@link ChatEvents.SpeakToTop }
 */
export declare interface ChatMsgSpeakCancelTopType extends ChatMsgCommonBasicType<ChatMsgSource.SpeakCancelTop>, OnSpeakCancelTopType {
}

/**
 * 聊天室消息类型 - 评论上墙
 * @warn 只有聊天重放才会用到该类型，但不会通过 ChatMessage 触发出去，而是使用 {@link ChatEvents.SpeakToTop }
 */
export declare interface ChatMsgSpeakTopType extends ChatMsgCommonBasicType<ChatMsgSource.SpeakTop>, SliceIdSpeakTop {
}

/**
 * 聊天室消息类型 - 发言
 * @source {@link ChatMsgSource.Speak}
 */
export declare interface ChatMsgSpeakType extends ChatMsgCommonType<ChatMsgSource.Speak> {
    /** 发言内容 */
    content: string;
    /** 回复内容 */
    quote?: ChatMsgQuoteType;
    /** 是否本地发送的消息 */
    isLocal?: boolean;
    /**
     * 是否已超出服务端文本长度
     * @version v0.11.0
     * */
    overLen?: boolean;
    /**
     * 是否超长文本
     * @desc 超出服务端文本长度或者大于 500 字符数
     * */
    isOverLength?: boolean;
    /**
     * 是否已经发送完成
     * @version v1.2.0
     * */
    isSended?: boolean;
    /**
     * 是否发送失败
     * @version v1.3.0
     */
    isSendFailed?: boolean;
}

/**
 * 聊天室消息类型 - 系统消息
 * @source {@link ChatMsgSource.System}
 */
export declare interface ChatMsgSystemType extends ChatMsgCommonBasicType<ChatMsgSource.System> {
    /** 消息内容 */
    content: string;
    type?: string;
}

/** 聊天室消息类型 */
export declare type ChatMsgType = ChatMsgTypeMap[keyof ChatMsgTypeMap];

/**
 * 聊天消息绑定关系
 */
export declare type ChatMsgTypeMap = {
    [ChatMsgSource.CustomMessage]: ChatMsgCustomMessageType;
    [ChatMsgSource.CustomerMessage]: ChatMsgCustomerMessageType;
    [ChatMsgSource.Emotion]: ChatMsgEmotionType;
    [ChatMsgSource.File]: ChatMsgFileType;
    [ChatMsgSource.Image]: ChatMsgImageType;
    [ChatMsgSource.Redpaper]: ChatMsgRedpaperType;
    [ChatMsgSource.RedpaperReceive]: ChatMsgRedpaperReceiveType;
    [ChatMsgSource.Reward]: ChatMsgRewardType;
    [ChatMsgSource.Speak]: ChatMsgSpeakType;
    [ChatMsgSource.System]: ChatMsgSystemType;
    [ChatMsgSource.MotivationLike]: ChatMsgMotivationLikeType;
    [ChatMsgSource.SpeakTop]: ChatMsgSpeakTopType;
    [ChatMsgSource.SpeakCancelTop]: ChatMsgSpeakCancelTopType;
    [ChatMsgSource.Effect]: ChatMsgEffectType;
    [ChatMsgSource.IarPushCard]: ChatMsgIarPushCardMessageType;
    [ChatMsgSource.IarCheckIn]: ChatMsgIarCheckInMessageType;
    [ChatMsgSource.IarAnswerCard]: ChatMsgIarAnswerCardMessageType;
    [ChatMsgSource.IarQuestionnaire]: ChatMsgIarQuestionnaireMessageType;
    [ChatMsgSource.Unknown]: ChatMsgUnknownMessageType;
};

/**
 * 聊天室消息类型 - 未知
 * @source {@link ChatMsgSource.Unknown}
 */
export declare interface ChatMsgUnknownMessageType extends ChatMsgCommonType<ChatMsgSource.Unknown> {
    /** 源数据 */
    sourceData: unknown;
}

/** 聊天重放消息分段 */
export declare interface ChatReplayMsgPart {
    /** 消息数量 */
    count: number;
    /** 分段开始时间 */
    startTime: number;
    /** 分段结束时间 */
    endTime: number;
    /** 分段 Id */
    id: number;
}

export declare type ChatReplayMsgSpeakTopType = ChatMsgSpeakTopType & ChatMsgReplayField;

export declare type ChatReplayMsgType = ChatMsgType & ChatMsgReplayField;

export declare interface ChatReplayMsgTypeGroup {
    [second: string]: ChatReplayMsgType[];
}

/** 聊天重放请求历史数据模式 */
export declare enum ChatReplayRequestHistoryMode {
    /** 初始化/重置 */
    Init = 0,
    /** 加载旧数据 */
    Pre = 1,
    /** 加载新数据 */
    Next = 2
}

export declare enum ChatReplaySpeakTopAction {
    Top = "top",
    CancelTop = "cancelTop"
}

/** 聊天请求历史数据模式 */
export declare enum ChatRequestHistoryMode {
    /** 加载旧数据 */
    Prev = "prev",
    /** 加载新数据 */
    Next = "next"
}

/**
 * 聊天室 sdk 类型导出及类型扩展
 * 原因：聊天室 sdk 中的类型定义不严谨，这里重新定义一次类型
 */

/**
 * 聊天室 sdk 消息公用类型
 */
export declare interface ChatSdkCommonMsgType {
    /** 消息唯一标识 */
    id: string;
    /** 时间 */
    time: number;
    /** 用户信息 */
    user: ChatMessageUser;
}

/**
 * 聊天室 sdk 消息类型 - 自定义消息(服务端)
 */
export declare interface ChatSdkCustomerMsgType {
    /** 消息类型 */
    msgType: 'CUSTOMER_MESSAGE';
    /** 消息 id */
    id: string;
    /** 消息内容 */
    content: string;
    /** 用户信息 */
    user: ChatMessageUser;
}

/**
 * 聊天室 sdk 消息类型 - 自定义消息(客户端)
 */
export declare interface ChatSdkCustomMsgType extends CustomMessageSocketType {
    /** 消息 id */
    id: string;
    /** 时间 */
    time: number;
    /** 用户信息 */
    user: ChatMessageUser;
}

/**
 * 聊天室 sdk 消息类型 - 表情
 */
export declare interface ChatSdkEmotionMsgType {
    /** 消息类型 */
    msgType: 'EMOTION';
    /** 消息唯一标识 */
    id: string;
    /** 表情图片内容 */
    content: {
        /** 图片 id */
        id: string;
        /** 表情图片地址 */
        uploadImgUrl: string;
    };
    /** 用户信息 */
    user: ChatMessageUser;
}

/**
 * 聊天室 sdk 消息类型 - 图片
 */
export declare interface ChatSdkImgMsgType extends ChatSdkCommonMsgType {
    /** 消息类型 */
    msgType: 'CHAT_IMG';
    /** 图片内容 */
    content: {
        /** 图片 id */
        id: string;
        /** 图片尺寸 */
        size: {
            width: number;
            height: number;
        };
        /** 图片地址 */
        uploadImgUrl: string;
    };
    /** 图片结果，false 时违规 */
    result?: false;
}

export declare interface ChatSdkQuoteCommon {
    /** 用户昵称 */
    nick: string;
    /** 用户信息 */
    user?: ChatMessageUser;
}

/**
 * 聊天室 sdk 消息中的 quote 字段类型（图片）
 */
export declare interface ChatSdkQuoteImgType extends ChatSdkQuoteCommon {
    /** 消息类型 */
    msgType: 'CHAT_IMG';
    /** 图片内容 */
    image: {
        url: string;
        width: number;
        height: number;
    };
    /** 用户 id */
    userId: string;
}

/**
 * 聊天室 sdk 消息中的 quote 字段类型（发言、自定义消息）
 */
export declare interface ChatSdkQuoteNormalType extends ChatSdkQuoteCommon {
    /** 消息类型 */
    msgType: 'NORMAL';
    /** 消息内容 */
    content: string;
    /** 用户 id */
    userId: string;
}

/**
 * 聊天室 sdk 消息中的 quote 字段类型（红包）
 */
export declare interface ChatSdkQuoteRedpaperType extends ChatSdkQuoteCommon {
    /** 消息类型 */
    msgType: 'REDPAPER';
    /** 红包内容 */
    content: ChatMsgRedpaperData;
}

/**
 * 聊天室 sdk 消息中的 quote 字段类型
 */
export declare type ChatSdkQuoteType = ChatSdkQuoteNormalType | ChatSdkQuoteImgType | ChatSdkQuoteRedpaperType;

/**
 * 聊天室 sdk 消息类型 - 红包
 */
export declare interface ChatSdkRedpaperMsgType extends ChatMsgRedpaperData {
    /** 消息类型 */
    msgType: 'REDPAPER';
    /** 发送时间 */
    timestamp: number;
    /** 发送的用户信息 */
    user: ChatMessageUser;
}

/**
 * 聊天室 sdk 消息类型 - 领取红包
 */
export declare interface ChatSdkRedpaperResultMsgType {
    /** 消息类型 */
    msgType: 'RED_PAPER_RESULT';
    /** 领取用户昵称 */
    nick: string;
    /** 红包 id */
    redpackId: string;
    /** 红包类型 */
    type: RedpackType;
    /** 是否领取完毕 */
    isOver: YN;
}

/**
 * 聊天室 sdk 消息类型 - 打赏
 */
export declare interface ChatSdkRewardMsgType {
    /** 消息类型 */
    msgType: 'REWARD';
    /** 房间号 */
    roomId: string;
    /** 打赏内容 */
    content: {
        /** 打赏道具图片，为空时为现金打赏 */
        gimg: string;
        /** 打赏数量 */
        goodNum: number;
        /** 打赏道具名称或打赏金额 */
        rewardContent: string;
        /** 打赏用户昵称 */
        unick: string;
        /** 打赏用户头像 */
        uimg?: string;
        /** 打赏用户信息 */
        rewardUser: {
            userId: string;
        };
    };
}

/**
 * 聊天室 sdk 消息类型 - 发言（文件分享）
 */
export declare interface ChatSdkSpeakFileMsgType extends ChatSdkCommonMsgType {
    /** 消息类型 */
    msgType: 'FILE';
    /** 文件内容 */
    content: {
        /** 文件名称 */
        name: string;
        /** 文件地址 */
        url: string;
    };
}

/**
 * 聊天室 sdk 消息类型 - 发言
 */
export declare type ChatSdkSpeakMsgType = ChatSdkSpeakNormalMsgType | ChatSdkSpeakFileMsgType;

/**
 * 聊天室 sdk 消息类型 - 发言（普通发言）
 */
export declare interface ChatSdkSpeakNormalMsgType extends ChatSdkCommonMsgType {
    /** 消息类型 */
    msgType: 'NORMAL';
    /** 发言内容 */
    content: string;
    /** 回复字段 */
    quote?: ChatSdkQuoteType;
    /** 是否超长 */
    overLen?: boolean;
}

/**
 * 聊天室设置信息
 */
export declare interface ChatSetting {
    /** 聊天室是否长时间未使用 */
    watchChatEnabled: boolean;
    /** 是否显示自定义消息 */
    showCustomMessageEnabled: boolean;
    /** 聊天引用回复开关 */
    quoteReplyEnabled: boolean;
    /** 翻译开关 */
    chatTranslateEnabled: boolean;
    /** 虚拟人数开关 */
    chatRobotEnabled: boolean;
    /** 聊天室并发人数限制开关 */
    restrictChatEnabled: boolean;
    /** 点赞开关 */
    likeEnabled: boolean;
    /** 单击点赞开关 */
    likeSingleClickEnabled: boolean;
    /** 长按点赞开关 */
    likeHoldEnabled: boolean;
    /** 是否只看主持人信息 */
    filterManagerMsgEnabled: boolean;
    /** 发送图片开关 */
    viewerSendImgEnabled: boolean;
    /**
     * 欢迎语开关
     * @todo 下个主要版本移除
     */
    welcomeEnabled: boolean;
    /** 情绪反馈开关 */
    emotionalFeedbackEnabled: boolean;
    /** 聊天室在线人数开关 */
    chatOnlineNumberEnable: boolean;
    /**
     * 黄脸表情开关
     * @version v0.6.0
     *  */
    faceEmotionEnabled: boolean;
    /**
     * 图片表情开关
     * @version v0.6.0
     * */
    imageEmotionEnabled: boolean;
    /**
     * 根据时间戳获取聊天历史记录
     * @version v0.9.0
     */
    getChatHistoryByTimestampEnabled: boolean;
    /**
     * 聊天消息布局
     * @version v2.3.0
     */
    chatMessageLayout: ChatMessageLayout;
    /**
     * 竖屏聊天消息布局
     * @version v2.3.0
     */
    portraitChatMessageLayout: ChatMessageLayout;
    /**
     * 聊天消息头像是否显示
     * @version v2.3.0
     */
    chatMessageAvatarDisplay: boolean;
    /**
     * 竖屏聊天消息头像是否显示
     * @version v2.3.0
     */
    portraitChatMessageAvatarDisplay: boolean;
    /**
     * 聊天室 UI 版本
     * @version v2.9.0
     */
    chatUIVersion: 'v1' | 'v2';
    /**
     * 点赞图标
     * @version v2.12.0
     */
    likeIconUrl: string;
    /**
     * 点赞图标类型
     * @version v2.17.0
     * @desc -1 为自定义上传图标，0 为默认图标，其余值表示为需要做多皮肤处理的图标
     */
    likeIconType: string;
    /**
     * 点赞特效类型
     * @version v2.12.0
     */
    likeEffectType: LikeEffectType;
    /**
     * 点赞特效配置
     * @version v2.12.0
     */
    likeEffectIcons: string[];
    /**
     * 是否显示点赞数
     * @version v2.12.0
     */
    likeCountEnabled: boolean;
}

/**
 * 聊天室服务令牌数据
 */
declare interface ChatTokenData {
    chatToken: string;
}

/** 用户身份类型枚举（聊天室） */
export declare enum ChatUserType {
    /** 普通频道观众身份 */
    Student = "student",
    /** 云课堂频道观众身份 */
    Slice = "slice",
    /** 观众 */
    Viewer = "viewer",
    /** 讲师 */
    Teacher = "teacher",
    /** 助教 */
    Assistant = "assistant",
    /** 管理员 */
    Manager = "manager",
    /** 嘉宾 */
    Guest = "guest",
    /** 研讨会参与者 */
    Attendee = "attendee",
    /** 研讨会观众身份 */
    Listener = "listener",
    /** 研讨会主持人 */
    Host = "host",
    /** 虚拟人 */
    Dummy = "dummy"
}

export declare namespace CheckAuthPayStatusRequest {
    export interface RequestParams {
        /** 订单 id */
        payId: string;
    }
    export interface ResponseData {
        /** 是否已支付 */
        hasPay: YN;
    }
}

export declare namespace CheckAuthWechatPayStatusRequest {
    export interface RequestParams {
        /** 订单 id */
        logId: string;
    }
    export interface ResponseData {
        /** 是否已支付 */
        hasPay: YN;
    }
}

/**
 * 检查支付打赏状态参数
 */
export declare interface CheckDonatePayStatusParams {
    /** 记录id */
    logId: string;
    /** 打赏类型 */
    donateType: DonateType;
}

declare class CheckIn extends InteractionBase_2 {
    static appName: string;
    CheckInEvent: typeof CheckInEvent;
    CheckInFailReason: typeof CheckInFailReason;
    eventEmitter: EventEmitter<CheckInEventRelations, CheckInEvent>;
    /** 当前签到 id */
    currentCheckInId?: string;
    /** 缓存的签到数据 */
    private __cacheCheckInData?;
    /** 是否开启强制签到 */
    private __forceCheckInEnabled?;
    private __countdownTimer?;
    constructor(interactionCore: InteractionCore);
    private __processSocketCache;
    private __onSliceID;
    private __onSignIn;
    private __onStopSignIn;
    private __startCountdown;
    private __onCountdownUpdate;
    private __stopCountdown;
    getCheckInData(): CheckInData | undefined;
    /**
     * 观众签到
     */
    toCheckIn(): Promise<CommonResult_2<CheckInFailReason>>;
    /**
     * 获取签到记录
     */
    getCheckInRecord(): Promise<GetCheckInRecordResponse>;
    /**
     * 判断用户是否已签到
     */
    isUserCheckedIn(): Promise<boolean>;
    /**
     * 获取强制签到开关
     */
    getForceCheckInEnabled(): boolean;
}

/**
 * 签到信息
 */
declare interface CheckInData {
    /** 签到 id */
    checkInId: string;
    /** 签到开始时间，单位：时间戳 */
    createTime: number;
    /** 签到剩余时间，单位：秒 */
    limitTime: number;
    /** 签到提示语 */
    message: string;
    /** 提示音效开关 */
    soundEnabled: boolean;
}

declare enum CheckInEvent {
    /**
     * 正在签到
     */
    OnCheckIn = "OnCheckIn",
    /**
     * 开始签到
     */
    StartCheckIn = "StartCheckIn",
    /**
     * 签到倒计时
     */
    CheckInCountdown = "CheckInCountdown",
    /**
     * 结束签到
     */
    StopCheckIn = "StopCheckIn",
    /**
     * 签到成功
     */
    CheckInSuccess = "CheckInSuccess",
    /**
     * 签到失败
     */
    CheckInFail = "CheckInFail"
}

declare type CheckInEventRelations = {
    [CheckInEvent.OnCheckIn]: {
        /**
         * 是否在签到中
         */
        isCheckInProcessing: boolean;
    };
    [CheckInEvent.StartCheckIn]: {
        /**
         * 签到数据
         */
        checkInData: CheckInData;
    };
    [CheckInEvent.CheckInCountdown]: {
        /**
         * 倒计时时间
         */
        remainingTime: number;
    };
    [CheckInEvent.StopCheckIn]: {
        /**
         * 签到 id
         */
        checkInId: string;
        /**
         * 签到人数
         */
        checkInCount?: number;
    };
    [CheckInEvent.CheckInSuccess]: null;
    [CheckInEvent.CheckInFail]: {
        /** 签到失败原因 */
        failReason: CheckInFailReason;
    };
};

/**
 * 签到失败原因
 */
declare enum CheckInFailReason {
    /**
     * 未知原因
     */
    Unknown = "Unknown",
    /**
     * 当前频道没有发起签到
     */
    NotCheckingIn = "NotCheckingIn"
}

/**
 * 签到记录数据
 */
declare interface CheckInRecordData {
    /**
     * 签到 id
     */
    checkInId: string;
    /**
     * 签到时间
     */
    createTime: string;
    /**
     * 签到状态
     */
    checked: boolean;
}

declare interface CheckInRecordData_2 {
    checkinId: string;
    createTime: string;
    checked: YN_3;
}

/**
 * 敏感词检测失败原因
 */
declare enum CheckSensitiveWordsFailReason {
    /**
     * 内容长度超过限制
     */
    ContentLimit = "ContentLimit",
    /**
     * 未知
     */
    Unknown = "Unknown"
}

export declare interface CheckWithdrawStatusParams {
    /** 提现单号 */
    outBillNo: string;
}

/**
 * 小班课统计配置
 */
declare interface ClassStatConfig {
    /** 是否启用小班课统计 */
    enabled: boolean;
    /** 是否累加 pd（播放时长），默认 false */
    enablePd?: boolean;
    /** 统计上报间隔（秒），默认 10 */
    interval?: number;
    /** 统计参数配置 */
    config: StatConfig;
}

/**
 * 小班课统计状态
 */
declare interface ClassStatStatus {
    /** 是否启用 */
    enabled: boolean;
    /** pd 是否正在累加 */
    running: boolean;
    /** 当前播放时长（秒） */
    pd: number;
    /** 当前在线时长（秒） */
    sd: number;
}

declare interface CollectItem {
    /** 收集项名称 */
    field: string;
    /** 收集项提示 */
    tips: string;
    /** 收集项类型 */
    type: CollectItemType;
    /** 是否必填 */
    required: boolean;
}

declare enum CollectItemType {
    /** 用户名 */
    UserName = "userName",
    /** 用户手机 */
    UserPhone = "userPhone",
    /** 地址 */
    Address = "address",
    /** 实物 */
    Custom = "custom"
}

/**
 * 评论抽奖条件
 */
declare interface CommentCondition extends LotteryConditionBase<LotteryCondition.Comment> {
    /**
     * 评论文本
     */
    commentText: string;
}

/**
 * 通用选项
 */
export declare interface CommonOption<T> {
    label: string;
    value: T;
}

/**
 * 结果类型
 */
export declare type CommonResult<FailReason extends string = string, SuccessData extends object = object> = ResultSuccess<SuccessData> | ResultFail<FailReason>;

/**
 * 结果类型
 */
declare type CommonResult_2<FailReason extends string = string, SuccessData extends object = object> = ResultSuccess_2<SuccessData> | ResultFail_2<FailReason>;

/**
 * 结果类型
 */
declare type CommonResult_3<FailReason extends string = string, SuccessData extends object = object> = ResultSuccess_3<SuccessData> | ResultFail_3<FailReason>;

declare interface CommonSpecialAuthSignParams {
    /**
     * 用户 id
     */
    userid: string;
    /**
     * 时间戳
     */
    ts: string;
    /**
     * 授权签名
     */
    sign: string;
}

/**
 * 连麦异常原因
 */
export declare enum ConnectMicError {
    /**
     * 当前环境不支持连麦
     */
    NotSupport = "NotSupport",
    /**
     * 获取设备权限失败
     */
    GetDevicePermissionFail = "GetDevicePermissionFail",
    /**
     * 找不到本地连麦流
     */
    LocalStreamNotFound = "LocalStreamNotFound"
}

/**
 * 连麦模块事件
 * @eventenum {@link ConnectMicEventsRelations}
 */
export declare enum ConnectMicEvents {
    /**
     * 连麦信息改变
     * @description 连麦信息通过 `connectMic.getConnectMicInfo()` 获取，当连麦信息改变时会触发该事件。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.ConnectMicInfoChange, () => {
     *   const connectMicInfo = watchCore.connectMic.getConnectMicInfo();
     *   console.log('连麦信息更新', connectMicInfo);
     * });
     * ```
     */
    ConnectMicInfoChange = "ConnectMicInfoChange",
    /**
     * 连麦网络信息改变
     * @description 连麦网络状态信息通过 `connectMic.getNetworkInfo()` 获取，当连麦网络状态信息改变时会触发该事件。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.NetworkInfoChange, () => {
     *   const networkInfo = watchCore.connectMic.getNetworkInfo();
     *   console.log('网络状态改变', networkInfo);
     * });
     * ```
     */
    NetworkInfoChange = "NetworkInfoChange",
    /**
     * 讲师开启连麦功能
     * @description 讲师开启连麦功能后，触发该事件，开启后页面即可显示连麦功能。
     * @example
     * ```js
     * import { ConnectMicType } from '@polyv/live-watch-sdk';
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.OpenConnectMic, (data) => {
     *   const type = data.type === ConnectMicType.Video ? '视频' : '音频';
     *   toast.info(`讲师开启了${type}连麦，赶快和主讲连麦互动吧～`);
     * });
     * ```
     */
    OpenConnectMic = "OpenConnectMic",
    /**
     * 讲师关闭连麦功能
     * @description 讲师关闭连麦功能后触发该事件
     * @example
     * ```js
     * import { ConnectMicType } from '@polyv/live-watch-sdk';
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.CloseConnectMic, (data) => {
     *   const type = data.type === ConnectMicType.Video ? '视频' : '音频';
     *   toast.info(`讲师已结束${type}连麦`);
     * });
     * ```
     */
    CloseConnectMic = "CloseConnectMic",
    /**
     * 连麦列表修改
     * @description 当观众上下麦或用户流加入/退出后，连麦列表改变，通过该事件监听连麦用户列表更新。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.ConnectMicListChange, () => {
     *   const connectMicList = watchCore.connectMic.getConnectMicList();
     *   console.log('连麦用户列表更新', connectMicList);
     * });
     * ```
     */
    ConnectMicListChange = "ConnectMicListChange",
    /**
     * 讲师挂断当前连麦者
     * @description 当讲师挂断当前连麦用户，连麦模块将回调该事件。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.TeacherHangUp, () => {
     *   toast.info('讲师已挂断你的连麦');
     * });
     * ```
     */
    TeacherHangUp = "TeacherHangUp",
    /**
     * 邀请上麦
     * @description 当讲师邀请观众上麦时触发该事件。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.InviteConnectMic, () => {
     *   watchCore.connectMic.openInviting();
     * });
     * ```
     */
    InviteConnectMic = "InviteConnectMic",
    /**
     * 邀请上麦回复
     * @version v1.3.0
     * @description 当学员对被邀请上麦是做处接受或拒绝操作时触发该事件
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.InviteConnectMic, (data) => {
     *   console.log(`学员是否拒绝上麦：${data.accept}, 拒绝上麦是否是因为操作超时：${data.timeout}`)
     * });
     * ```
     */
    InviteConnectMicAnswer = "InviteConnectMicAnswer",
    /**
     * 设备采集失败
     * @version v0.7.0
     * @description 媒体设备(摄像头/麦克风)自动恢复采集失败，摄像头、麦克风接口松动，或被其他应用占用。恢复采集失败时触发该事件。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.DeviceRecoverFail, () => {
     *   toast.error('自动采集失败，请检查设备正常连接后刷新页面重新进入');
     * });
     * ```
     */
    DeviceRecoverFail = "DeviceRecoverFail",
    /**
     * 连麦人数到达上限
     * @description 观众点击同意邀请上麦时，可能因连麦人数到达上限而连麦失败，通过该事件监听并页面提示。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.ConnectMicOverLimit, () => {
     *   toast.error('连麦失败，连麦人数已到达上限');
     * });
     * ```
     */
    ConnectMicOverLimit = "ConnectMicOverLimit",
    /**
     * 当前主讲状态改变
     * @description 当讲师授予/撤销当前连麦用户的主讲权限时触发该事件。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.CurrentSpeakerStatusChanged, (data) => {
     *   if (data.currentIsSpeaker) {
     *     toast.info('讲师已授予您主讲权限');
     *   } else {
     *     toast.info('讲师已收回您的主讲权限');
     *   }
     * });
     * ```
     */
    CurrentSpeakerStatusChanged = "CurrentSpeakerStatusChanged",
    /**
     * 讲师同意连麦申请
     * @description 观众申请连麦，讲师同意连麦申请后触发该事件。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.AllowConnectMicApply, (data) => {
     *   toast.success('讲师已同意你的连麦申请');
     * });
     * ```
     */
    AllowConnectMicApply = "AllowConnectMicApply",
    /**
     * 本地流初始化成功
     * @description 讲师同意连麦申请，本地流初始化完成后触发该事件，触发后即可推送本地连麦流。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.LocalStreamInited, () => {
     *   watchCore.connectMic.publishLocalStream({
     *     element: 'NodeElement',
     *   });
     * });
     * ```
     */
    LocalStreamInited = "LocalStreamInited",
    /**
     * 本地流推送成功
     * @description 本地连麦流推送成功后触发该事件，触发后连麦状态为 {@link ConnectMicStatus.Connected}。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.PublishStreamSuccess, () => {
     *   toast.success('上麦成功');
     *   const connectMicInfo = watchCore.connectMic.getConnectMicInfo();
     *   console.log('连麦状态', connectMicInfo.connectMicStatus); // ConnectMicStatus.Connected
     * });
     * ```
     */
    PublishStreamSuccess = "PublishStreamSuccess",
    /**
     * 离开连麦成功
     * @description 本地连麦流离开后触发该事件，触发后连麦状态为 {@link ConnectMicStatus.NotConnect}。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.LeaveConnectMicSuccess, () => {
     *   toast.success('你已下麦');
     *   const connectMicInfo = watchCore.connectMic.getConnectMicInfo();
     *   console.log('连麦状态', connectMicInfo.connectMicStatus); // ConnectMicStatus.NotConnect
     * });
     * ```
     */
    LeaveConnectMicSuccess = "LeaveConnectMicSuccess",
    /**
     * 远端连麦用户麦克风开关改变
     * @version v2.0.0
     */
    RemoteAudioMuteChange = "RemoteAudioMuteChange",
    /**
     * 远端连麦用户摄像头开关改变
     * @version v2.0.0
     */
    RemoteVideoMuteChange = "RemoteVideoMuteChange",
    /**
     * 本地麦克风开关改变
     * @version v2.0.0
     */
    LocalAudioMuteChange = "LocalAudioMuteChange",
    /**
     * 本地摄像头开关改变
     * @version v2.0.0
     */
    LocalVideoMuteChange = "LocalVideoMuteChange",
    /**
     * 切换第一画面
     * @version v2.0.0
     * @description 讲师切换第一画面时触发该事件
     */
    SwitchMaster = "SwitchMaster",
    /**
     * 屏幕共享信息改变
     * @description 屏幕恭喜信息改变时触发该事件
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.ScreenShareInfoChange, () => {
     *   const screenShareInfo = watchCore.connectMic.getScreenShareInfo();
     *   console.log('屏幕共享信息改变', screenShareInfo);
     * });
     * ```
     */
    ScreenShareInfoChange = "ScreenShareInfoChange",
    /**
     * 屏幕共享开始
     * @description 观众开始屏幕共享时触发该事件。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.ScreenShareStart, () => {
     *   toast.info('你已进入屏幕共享');
     * });
     * ```
     */
    ScreenShareStart = "ScreenShareStart",
    /**
     * 屏幕共享结束
     * @description 观众结束屏幕共享时触发该事件。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.ScreenShareStart, () => {
     *   toast.info('你已退出屏幕共享');
     * });
     * ```
     */
    ScreenShareStop = "ScreenShareStop",
    /**
     * 举手申请连麦超时
     * @version v2.0.0
     * @description 观众举手申请连麦超时时触发该事件。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.ApplyTimeOut, () => {
     *   toast.info('你已申请超时');
     * });
     * ```
     */
    ApplyTimeOut = "ApplyTimeOut",
    /**
     * 前后摄像头切换
     * @version v2.6.0
     * @description 前后摄像头切换时触发该事件
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.FacingModeChange, () => {
     *   toast.info(watchCore.connectMic.getConnectMicInfo().facingMode);
     * });
     * ```
     */
    FacingModeChange = "FacingModeChange",
    /**
     * 用户流播放失败
     * @version v2.13.0
     * @description 用户流播放失败时触发该事件
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.UserStreamPlayFailed, (data) => {
     *   toast.error('用户流播放失败');
     * });
     * ```
     */
    UserStreamPlayFailed = "UserStreamPlayFailed",
    /**
     * 邀请上麦倒计时
     * @version v2.17.0
     * @description 收到讲师邀请后，距离自动拒绝的剩余时间发生变化时触发该事件，开发者可用于自定义邀请上麦 UI 的倒计时显示。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.InviteCountDown, (data) => {
     *   console.log(`剩余 ${data.remain}s / 总 ${data.total}s`);
     * });
     * ```
     */
    InviteCountDown = "InviteCountDown",
    /**
     * 本地音视频开关变更（预设 / 预览阶段）
     * @version v2.17.0
     * @description 未连麦时（预设 / 预览阶段）本地摄像头、麦克风开关发生变化时触发，例如在设备检测面板中修改了设备开关。开发者可用于同步自定义连麦面板的设备按钮状态。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.LocalMuteStatusChange, (data) => {
     *   console.log('摄像头是否关闭：', data.video, '麦克风是否关闭：', data.audio);
     * });
     * ```
     */
    LocalMuteStatusChange = "LocalMuteStatusChange"
}

/**
 * 连麦模块事件回调参数配置
 */
export declare type ConnectMicEventsRelations = {
    [ConnectMicEvents.ConnectMicInfoChange]: {
        /**
         * 连麦信息
         */
        connectMicInfo: ConnectMicStoreInfo;
    };
    [ConnectMicEvents.NetworkInfoChange]: {
        /**
         * 连麦网络信息
         */
        networkInfo: ConnectMicNetworkInfo;
    };
    [ConnectMicEvents.OpenConnectMic]: {
        /**
         * 连麦类型
         */
        type: ConnectMicType;
    };
    [ConnectMicEvents.CloseConnectMic]: {
        /**
         * 连麦类型
         */
        type: ConnectMicType;
    };
    [ConnectMicEvents.ConnectMicListChange]: {
        /**
         * 连麦列表
         */
        connectMicList: ConnectMicItem[];
    };
    [ConnectMicEvents.LocalStreamInited]: {
        /**
         * 连麦用户节点
         */
        micItem: ConnectMicItem;
    };
    [ConnectMicEvents.RemoteAudioMuteChange]: {
        /**
         * 连麦用户节点
         */
        micItem: ConnectMicItem;
        /**
         * 是否关闭麦克风
         */
        isAudioMuted: boolean;
    };
    [ConnectMicEvents.RemoteVideoMuteChange]: {
        /**
         * 连麦用户节点
         */
        micItem: ConnectMicItem;
        /**
         * 是否关闭摄像头
         */
        isVideoMuted: boolean;
    };
    [ConnectMicEvents.LocalAudioMuteChange]: {
        /**
         * 连麦用户节点
         */
        micItem: ConnectMicItem;
        /**
         * 是否关闭麦克风
         */
        isAudioMuted: boolean;
    };
    [ConnectMicEvents.LocalVideoMuteChange]: {
        /**
         * 连麦用户节点
         */
        micItem: ConnectMicItem;
        /**
         * 是否关闭摄像头
         */
        isVideoMuted: boolean;
    };
    [ConnectMicEvents.SwitchMaster]: {
        /**
         * 当前第一画面的连麦用户节点
         */
        currentMaster: ConnectMicItem;
        /**
         * 上一次的连麦用户节点
         */
        previousMaster: ConnectMicItem;
    };
    [ConnectMicEvents.CurrentSpeakerStatusChanged]: {
        /**
         * 当前用户是否为主讲
         */
        currentIsSpeaker: boolean;
    };
    [ConnectMicEvents.ScreenShareInfoChange]: {
        /**
         * 屏幕共享信息
         */
        screenInfoChange: ScreenShareInfo;
    };
    [ConnectMicEvents.UserStreamPlayFailed]: {
        /**
         * 流ID
         */
        streamId: string;
    };
    [ConnectMicEvents.InviteCountDown]: InviteCountDownData;
    [ConnectMicEvents.LocalMuteStatusChange]: {
        /**
         * 是否关闭摄像头
         */
        video: boolean;
        /**
         * 是否关闭麦克风
         */
        audio: boolean;
    };
};

/**
 * 播放容器模式
 */
export declare enum ConnectMicFitType {
    Contain = "contain",
    Cover = "cover"
}

/**
 * 连麦用户节点
 * @class
 * @propertyExample
 * ```js
 * // 获取连麦用户列表
 * const connectMicList = watchCore.connectMic.getConnectMicList();
 * connectMicList.forEach((micItem) => {
 *   console.log('连麦用户流 id', micItem.streamId);
 *   console.log('该用户是否关闭摄像头', micItem.isVideoMuted);
 *   console.log('该用户是否关闭麦克风', micItem.isAudioMuted);
 * });
 * ```
 */
export declare class ConnectMicItem {
    /**
     * 连麦 rtc 流实例
     */
    private __streamInstance;
    /**
     * 用户流 id
     */
    streamId: string;
    /**
     * 是否本地推流
     */
    isLocal: boolean;
    /**
     * 是否为当前用户
     */
    isSelf: boolean;
    /**
     * 是否为第一画面
     */
    isMaster: boolean;
    /**
     * 是否讲师
     */
    isTeacher: boolean;
    /**
     * 本地流时，是否已推送
     */
    private __isPublished;
    /**
     * 用户流时，是否已订阅
     */
    private __isSubscribe;
    /**
     * 用户昵称
     */
    nickname: string;
    /**
     * 用户头像
     */
    pic: string;
    /**
     * 用户身份
     */
    userType: ChatUserType;
    /**
     * 是否关闭麦克风
     */
    isAudioMuted: boolean;
    /**
     * 当前音量(0 ~ 1)
     */
    currentVolume: number;
    /**
     * 是否关闭摄像头
     */
    isVideoMuted: boolean;
    /**
     * 是否开启镜像（仅本地流有效）
     */
    mirrorEnabled: boolean;
    /**
     * 是否 sip 电话连麦
     * @internal
     * @ignore
     */
    isSipUser: boolean;
    /**
     * 该用户的连麦方式
     */
    currentConnectMicType: ConnectMicType;
    /**
     * 是否自动播放失败
     */
    isPlayFail: boolean;
    /** 是否观众模式，仅拉主讲流 */
    isAudience: boolean;
    /**
     * 获取连麦模块
     * 这里为什么要做成方法？
     * 因为在 vue 里，item 可能会放到 pinia，这是 pinia 会处理成响应式，
     * 循环引用会造成栈溢出
     */
    private __getConnectMicModule;
    /**
     * 获取连麦 rtc 实例
     */
    private __getRtcInstance;
    /**
     * 流参数
     */
    private __streamOption?;
    constructor(options: ConnectMicItemOptions);
    /**
     * 判断是否为本地流
     * @param target 目标流实例
     */
    private __isLocalSteam;
    /**
     * 判断是否为用户流
     * @param target 目标流实例
     */
    private __isUserSteam;
    /**
     * 设置静音状态
     * @internal
     * @ignore
     * @param isAudioMuted 是否静音
     */
    __setMicItemAudioMuted(isAudioMuted: boolean): void;
    /**
     * 设置摄像头状态
     * @internal
     * @ignore
     * @param isVideoMuted 是否关闭摄像头
     */
    __setMicItemVideoMuted(isVideoMuted: boolean): void;
    /**
     * 设置第一画面
     * @internal
     * @ignore
     * @param isMaster 是否第一画面
     */
    __setMaster(isMaster: boolean): void;
    /**
     * 推送本地流
     *
     * 当主讲同意观众的连麦申请后，连麦状态会变为推送中 `ConnectMicStatus.Applying`，连麦模块会回调 {@link ConnectMicEvents.ConnectMicListChange} 连麦用户列表改变事件，开发者通过连麦用户节点的 `publishStream` 方法推送本地流。
     *
     * 推流成功后将触发 {@link ConnectMicEvents.PublishStreamSuccess} 事件。
     * @param options 推流参数
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.ConnectMicListChange, ({ connectMicList }) => {
     *   // 遍历连麦用户列表
     *   connectMicList.forEach((micItem) => {
     *     // 本地流节点
     *     if (micItem.isLocal) {
     *       // 推送本地流
     *       micItem.publishStream({
     *         element: 'NodeElement',
     *       });
     *     }
     *   });
     * });
     * ```
     */
    publishStream(options: PublishStreamOptions): void;
    /**
     * 订阅连麦用户流
     *
     * 当观众上麦或下麦后，连麦模块会回调 {@link ConnectMicEvents.ConnectMicListChange} 连麦用户列表改变事件，开发者可监听连麦用户列表改变事件获取新的连麦用户列表，通过连麦用户节点的 `subscribeStream` 方法订阅连麦用户流。
     * @param options 订阅流参数
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.ConnectMicListChange, ({ connectMicList }) => {
     *   // 遍历连麦用户列表
     *   connectMicList.forEach((micItem) => {
     *     if (micItem.isLocal) {
     *       // 推送本地流
     *       micItem.publishStream({
     *         element: 'NodeElement',
     *       });
     *     } else {
     *       // 订阅连麦流
     *       micItem.subscribeStream({
     *         element: 'NodeElement',
     *       });
     *     }
     *   });
     * });
     * ```
     */
    subscribeStream(options: SubscribeSteamOptions): void;
    /**
     * 恢复连麦流播放
     *
     * 自动播放失败后，用户节点 `isPlayFail` 会更改为 true，此时需要显示播放按钮，用户点击播放按钮后可调用该方法恢复流播放。
     * @example
     * ```js
     * if (micItem.isPlayFail) {
     *   console.log('显示节点的播放按钮');
     * }
     *
     * document.querySelector('播放按钮选择器').addEventListener('click', () => {
     *   // 恢复播放
     *   micItem.resumeStream();
     * });
     * ```
     */
    resumeStream(): void;
    /**
     * 刷新流
     */
    private __refreshStream;
    /**
     * 移除连麦用户流
     *
     * 当连麦节点销毁时，需要调用 `removeStream` 方法移除用户流，以 vue 组件销毁为例：
     * @example
     * ```js
     * export default {
     *   beforeDestroy() {
     *     this.micItem.removeStream();
     *   }
     * };
     * ```
     */
    removeStream(): void;
    /**
     * 刷新音量
     * @internal
     * @ignore
     */
    refreshVolume(): void;
}

export declare interface ConnectMicItemOptions {
    /**
     * 连麦模块
     */
    connectMic: PlvConnectMicModule;
    /**
     * 流实例
     */
    streamInstance: MicStreamInstance;
    /**
     * 是否本地推流
     */
    isLocal: boolean;
    /**
     * 获取 rtc 实例
     */
    getRtcInstance(): RtcWebSdkInstance | undefined;
    /**
     * 是否为观众模式
     */
    isAudience?: boolean;
}

/**
 * 连麦网络信息
 */
export declare interface ConnectMicNetworkInfo {
    /**
     * 连麦上行网络质量
     */
    uplinkNetworkQuality: UplinkNetworkQuality;
    /**
     * 连麦上行网络状态
     */
    uplinkNetworkStatus: NetworkStatus;
    /**
     * 连麦下行网络质量
     */
    downlinkNetworkQuality: DownlinkNetworkQuality;
    /**
     * 连麦下行网络状态
     */
    downlinkNetworkStatus: NetworkStatus;
}

/**
 * 连麦结果
 */
export declare type ConnectMicResult = CommonResult<ConnectMicError>;

/**
 * 用户连麦状态
 */
export declare enum ConnectMicStatus {
    /**
     * 未连麦
     */
    NotConnect = "notConnect",
    /**
     * 连麦申请中
     */
    Applying = "applying",
    /**
     * 推流中
     */
    Publishing = "publishing",
    /**
     * 已连麦
     */
    Connected = "connected",
    /**
     * 连麦异常
     */
    Error = "error"
}

/**
 * 连麦信息
 */
export declare interface ConnectMicStoreInfo {
    /**
     * 当前环境是否支持连麦
     */
    supportConnectMic: boolean;
    /**
     * 当前环境是否支持切换前后摄像头
     * @version v2.6.0
     */
    supportFacingMode: boolean;
    /**
     * 当前前后摄像头
     * @version v2.6.0
     */
    facingMode: FacingMode;
    /**
     * 是否开启镜像
     * @version v2.10.0
     */
    mirrorEnabled: boolean;
    /**
     * 连麦状态，开启或关闭
     */
    openMicStatus: boolean;
    /**
     * 邀请上麦状态
     * @version v1.3.0
     * 在收到邀请直到拒绝邀请或受邀上麦后下麦的过程中为true
     * 如果不开启新版连麦，在申请举手关闭情况下该状态为false
     */
    inviteStatus: boolean;
    /**
     * 连麦类型
     */
    connectMicType: ConnectMicType;
    /**
     * 用户连麦状态
     */
    connectMicStatus: ConnectMicStatus;
    /**
     * 连麦排序显示开关
     */
    showJoinQueueNumberEnabled: boolean;
    /**
     * 连麦顺序索引值(-1 表示不在队列)
     */
    currentMicIndex: number;
    /**
     * 当前用户是否为主讲
     */
    currentIsSpeaker: boolean;
    /**
     * 点击开始连麦是否立刻上麦
     */
    autoConnect: boolean;
}

/**
 * 连麦类型
 *
 * 用于区分讲师开启的是视频连麦或音频连麦
 */
export declare enum ConnectMicType {
    /**
     * 视频连麦
     */
    Video = "video",
    /**
     * 音频连麦
     */
    Audio = "audio"
}

declare class Coupon extends InteractionBase_4 {
    config: CouponConfig;
    /** 应用名称 */
    static appName: string;
    /** 优惠券事件 */
    CouponEvent: typeof CouponEvent;
    /** 优惠券状态 */
    CouponStatus: typeof CouponStatus;
    /** 优惠券使用时间类型 */
    CouponUseTimeType: typeof CouponUseTimeType;
    /** 优惠券规则单位 */
    CouponRuleUnit: typeof CouponRuleUnit;
    /** 优惠券规则条件 */
    CouponRuleCondition: typeof CouponRuleCondition;
    /** 事件处理 */
    eventEmitter: EventEmitter<CouponEventRelations, CouponEvent>;
    private __couponEnabled;
    private __setCouponEnabled;
    /**
     * 获取优惠券开关状态
     * @example
     * ```js
     * const couponEnabled = couponTarget.getCouponEnabled();
     * console.info('优惠券开关状态', couponEnabled);
     * ```
     */
    getCouponEnabled(): boolean;
    constructor(interactionCore: InteractionCore, config?: CouponConfig);
    /** 添加 socket 处理 */
    private __addSocketHandles;
    private __processSocketCache;
    /** 刷新可领取优惠券列表 */
    private __onRefreshCouponList;
    /** 优惠券信息更新 */
    private __onReceiveCouponItemUpdate;
    /** 获取可领取优惠券列表 */
    getCouponCommonList(options?: PageOptions): Promise<PageContent_2<CouponCommonData>>;
    /** 领取优惠券 */
    receiveCoupon(couponId: string): Promise<void>;
    /** 获取已领取优惠券列表 */
    getCouponUserList(options?: PageOptions): Promise<PageContent_2<CouponUserData>>;
}

/**
 * 优惠券信息
 */
declare interface CouponBaseData {
    /**
     * 优惠券ID
     */
    couponId: string;
    /**
     * 优惠券名称
     */
    name: string;
    /**
     * 优惠券规则
     */
    rule: CouponRule;
    /**
     * 优惠券状态
     */
    status: CouponStatus;
}

/**
 * 优惠券可领取信息
 */
declare interface CouponCommonData extends CouponBaseData {
    /**
     * 领取后多少天内可用
     */
    dayOfUse: number;
    /**
     * 领取结束时间
     */
    receiveEndTime: number;
    /**
     * 领取开始时间
     */
    receiveStartTime: number;
    /**
     * 排序
     */
    sort: number;
    /**
     * 使用时间类型
     */
    useTimeType: CouponUseTimeType;
    /**
     * 剩余库存
     */
    remainAmount: number;
}

/**
 * 优惠券可领取列表
 */
declare interface CouponCommonListData {
    /**
     * 优惠券列表
     */
    couponList: CouponCommonData[];
}

/**
 * 优惠券配置
 */
declare interface CouponConfig {
    /**
     * 优惠券开关
     */
    couponEnabled?: boolean;
}

declare enum CouponEvent {
    /**
     * 刷新可领取优惠券列表
     */
    RefreshCouponList = "RefreshCouponList",
    /**
     * 新增优惠券
     */
    AddCouponItem = "AddCouponItem",
    /**
     * 删除优惠券
     */
    DeleteCouponItem = "DeleteCouponItem",
    /**
     * 更新优惠券信息
     */
    UpdateCouponItem = "UpdateCouponItem",
    /**
     * 切换优惠券开关
     */
    SwitchCoupon = "SwitchCoupon"
}

declare type CouponEventRelations = {
    /**
     * 刷新可领取优惠券列表
     */
    [CouponEvent.RefreshCouponList]: unknown;
    /**
     * 新增优惠券
     */
    [CouponEvent.AddCouponItem]: CouponCommonData[];
    /**
     * 删除优惠券
     */
    [CouponEvent.DeleteCouponItem]: CouponCommonData[];
    [CouponEvent.UpdateCouponItem]: CouponCommonData[];
    /**
     * 更新优惠券开关
     */
    [CouponEvent.SwitchCoupon]: CouponSwitchContent;
};

/** 优惠券使用条件 */
declare interface CouponRule {
    /**
     * 优惠券使用条件 UNCONDITIONAL-无门槛、FULL_REDUCE-满减
     */
    condition: keyof typeof CouponRuleCondition;
    /**
     * 满减金额
     */
    fullReduce: {
        /**
         * 是否开启
         */
        enable: boolean;
        /**
         * 满减金额
         */
        full: number;
        /**
         * 减免金额
         */
        reduce: number;
        /**
         * 单位 MONEY-元、DISCOUNT-折
         */
        unit: keyof typeof CouponRuleUnit;
    };
    /**
     * 无门槛
     */
    unconditional: {
        /**
         * 是否开启
         */
        enable: boolean;
        /**
         * 减免金额
         */
        value: number;
        /**
         * 单位 MONEY-元、DISCOUNT-折
         */
        unit: keyof typeof CouponRuleUnit;
    };
    /**
     * 每人限领 -1-不限制
     */
    limitPerPerson: number;
}

/** 优惠券使用条件 */
declare enum CouponRuleCondition {
    /** 无门槛 */
    UNCONDITIONAL = "UNCONDITIONAL",
    /** 满减 */
    FULL_REDUCE = "FULL_REDUCE"
}

/** 优惠券单位 */
declare enum CouponRuleUnit {
    /** 元 */
    MONEY = "MONEY",
    /** 折 */
    DISCOUNT = "DISCOUNT"
}

/** 优惠券状态 */
declare enum CouponStatus {
    /** 未开始 */
    NOT_START = "NOT_START",
    /** 进行中 */
    GOING = "GOING",
    /** 已结束 */
    FINISHED = "FINISHED",
    /** 已失效 */
    INVALID = "INVALID",
    /** 已删除 */
    DELETED = "DELETED"
}

declare interface CouponSwitchContent {
    /** 优惠券开关 */
    enable: string;
}

/**
 * 优惠券已领取信息
 */
declare interface CouponUserData extends CouponBaseData {
    /**
     * 结束时间
     */
    endTime: number;
    /**
     * 开始时间
     */
    startTime: number;
}

/**
 * 优惠券已领取列表
 */
declare interface CouponUserListData {
    /**
     * 优惠券列表
     */
    couponList: CouponUserData[];
}

/** 优惠券使用时间类型 */
declare enum CouponUseTimeType {
    /** 时间范围 */
    RANGE = "RANGE",
    /** 领取后可用 */
    DAY = "DAY"
}

/**
 * 创建订单参数
 */
export declare interface CreateOrderParams {
    /** 商品列表具体详细信息, 包括商品ID、商品数量 */
    products: Array<{
        /** 商品ID */
        productId: number;
        /** 商品数量 */
        quantity: number;
    }>;
    /** 购买商品的物流信息 */
    address: {
        /** 收货详细地址 */
        address?: string;
        /** 收货地区 */
        area?: string;
        /** 收货手机号 */
        mobile: string;
        /** 收货姓名 */
        name?: string;
    };
    /** 支付方式 */
    payProvider: PayProvider;
}

/**
 * 创建订单接口返回内容
 */
export declare interface CreateOrderResponse {
    /** 微信支付 jsapi, 支付宝订单码支付：qrCodeOffline */
    type: string;
    /** 二维码内容 */
    codeUrl: string;
    /** 支付 id */
    payId: string;
    /** 订单状态 */
    payStatus: PayStatus;
    /** 微信支付的签名数据 */
    /** 微信appId */
    appId: string;
    /** 随机数字符串 */
    nonceStr: string;
    /** 原package字段 */
    prepayId: string;
    /** 签名 */
    paySign: string;
    /** 签名类型 */
    signType: string;
    /** 时间戳 */
    timeStamp: string;
    /** 支付方式 */
    payProvider: PayProvider;
}

/**
 * 创建观看页核心实例
 * @param appConfig 配置选项
 * @returns 观看页核心实例
 * @example
 * ```js
 * import { createWatchCore } from '@polyv/live-watch-sdk';
 * const watchCore = createWatchCore({
 *   channelId: '频道号'
 * });
 * ```
 */
export declare function createWatchCore(appConfig: AppConfig, opts?: {
    /** 是否创建多实例 */
    multiEnable: boolean;
}): PolyvWatchCore;

declare function createWatchIdentifyCore(config?: IdentifyCoreConfig): IdentifyCore;

/**
 * 自定义授权签名参数
 */
export declare interface CustomAuthSignParams extends CommonSpecialAuthSignParams {
}

/**
 * 自定义授权地址数据
 */
export declare interface CustomAuthUrlData {
    /**
     * 自定义授权跳转地址
     */
    customAuthUrl: string;
}

/**
 * 观看页定制频道信息
 */
export declare interface CustomChannelSetting {
    /** 是否显示七国语言 */
    isShowSevenLanguage: YN;
    /** 双流特殊样式开关，为 N 时使用多音轨流 */
    doubleStreamCustomStyleEnabled: YN;
}

/**
 * 自定义消息(客户端)发送回调
 */
export declare interface CustomMessageSocketSendedCallback {
    /** 状态 */
    status: 'success' | 'fail';
    /** 自定义消息 id */
    data: string;
    /** 消息 */
    message: string;
}

/**
 * 自定义消息(客户端)
 */
declare interface CustomMessageSocketType<T extends object = object> {
    /** 自定义事件 */
    EVENT: string;
    /** 自定义版本 */
    version: number;
    /** 自定义消息体 */
    data: T;
    /** 自定义消息提示 */
    tip: string;
    /** 自定义消息是否加入聊天历史数据，默认加入 */
    joinHistoryList: boolean;
}

/**
 * 默认的浏览器 ico
 */
export declare const DEFAULT_BROWSER_ICON: string;

/**
 * 默认的频道 logo
 */
export declare const DEFAULT_CHANNEL_LOGO: string;

/**
 * 默认点赞图标
 */
export declare const DEFAULT_LIKE_ICON: string;

/**
 * 默认的回放首帧占位图
 */
export declare const DEFAULT_PLAYBACK_PLACEHOLDER: string;

/**
 * 默认引导页大图封面图
 */
export declare const DEFAULT_SPLASH_FULL_IMG: string;

/**
 * 默认引导页封面图
 */
export declare const DEFAULT_SPLASH_IMG: string;

/**
 * 默认观众头像
 */
export declare const DEFAULT_VIEWER_AVATAR: string;

/**
 * 默认图标（微活动）
 */
export declare const DEFAULT_WIDGET_GAME: string;

/**
 * 销毁观看页核心实例
 * @param watchCore 当创建多个 watchCore 实例时，可以将实例入参进行销毁
 */
export declare function destroyWatchCore(watchCore?: WatchCore): void;

export declare interface DetailSeatSetting {
    /** 云席模板 */
    template: SeatTableTemplate;
    /** 云席自定义文案开关 */
    customTextEnabled: YN;
    /** 云席自定义文案 */
    customText: string;
    /** 云席嘉宾证开关 */
    seatGuestCardEnabled: YN;
    /** 嘉宾普通云席最大数量 */
    seatMaxNumber: number;
    /** 嘉宾 vip 云席最大数量 */
    seatVipMaxNumber: number;
}

export declare interface DetailViewerSeatInfo {
    /** 介绍 */
    intro: string | null;
    /** 职级 */
    position: string | null;
    /** 云席Id */
    seatId: string;
    /** 座位号 */
    seatNumber: number;
    /** 云席类型: vip vip嘉宾  viewer 普通嘉宾 */
    type: ViewerSeatType;
    /** 云席开关 */
    viewerSeatEnabled: YN;
    /** 云席模板 */
    template: SeatTableTemplate;
}

/**
 * 独立授权失败地址数据
 */
export declare interface DirectAuthFailUrlData {
    /**
     * 独立授权失败跳转地址
     */
    directAuthFailUrl: string | undefined;
}

/**
 * 独立授权签名参数
 */
export declare interface DirectAuthSignParams extends CommonSpecialAuthSignParams {
    /**
     * 用户昵称
     */
    nickname: string;
}

declare interface DirectAuthSignParams_2 {
    /**
     * 用户 id
     */
    externalViewerId: string;
    /**
     * 用户昵称
     */
    nickname: string;
    /**
     * 时间戳
     */
    ts: number;
    /**
     * 签名
     */
    sign: string;
    /**
     * 头像
     */
    avatar?: string;
    /**
     * 自定义参数
     */
    param4?: string;
    /**
     * 自定义参数
     */
    param5?: string;
}

declare interface DocControlImp {
    /** 设置文档 */
    setup(options: SetupDocOptions): Promise<void>;
    /** 设置水印 */
    setWatermark(): void;
    /** 重置尺寸 */
    resize(): void;
    /** 设置回放 */
    setupPlayback(options: SetupDocPlaybackOptions): Promise<void>;
    /** 切换到下一步 */
    gotoNext(): void;
    /** 切换到上一步 */
    gotoPrev(): void;
    /** 销毁 */
    destroy(): void;
    /** 是否设置完成 */
    readonly setuped: boolean;
    /** 插入 socket 数据 */
    joinSocketDataCallback(params: JoinSocketDataCallbackParams): void;
    /** 进入画笔模式 */
    enterPaintMode(): void;
    /** 退出画笔模式 */
    exitPaintMode(): void;
    /** 设置键盘控制 */
    setKeyboardEnabled(enabled: boolean): void;
    /** 切换语言 */
    switchLang(lang: string): void;
    /** 获取 drawMark 数据 */
    getDrawMark(): Record<string, string[]> | undefined;
    /** 更改切页开关 */
    updateSwitchPageEnabled(enabled: boolean): void;
}

/** 文档事件 */
export declare enum DocEvents {
    /**
     * 文档信息更新
     */
    DocInfoChange = "DocInfoChange",
    /**
     * 画笔授权状态改变
     */
    PaintAuthStatusChange = "PaintAuthStatusChange",
    /**
     * 主副屏切换
     */
    MainScreenChange = "MainScreenChange",
    /**
     * 全屏状态改变
     */
    FullScreenStateChange = "FullScreenStateChange"
}

export declare type DocEventsRelations = {
    [DocEvents.DocInfoChange]: {
        /**
         * 文档信息
         */
        docInfo: DocModuleInfo;
    };
    [DocEvents.PaintAuthStatusChange]: {
        /**
         * 是否具有画笔权限
         */
        hasPaintAuth: boolean;
    };
    [DocEvents.MainScreenChange]: {
        /**
         * 主副屏位置
         */
        mainScreen: MainScreenContent;
    };
    [DocEvents.FullScreenStateChange]: {
        /**
         * 是否全屏
         */
        isFullScreen: boolean;
    };
};

export declare interface DocModuleInfo {
    /**
     * 是否具有画笔权限
     */
    hasPaintAuth: boolean;
    /**
     * 是否处于画笔模式
     */
    paintMode: boolean;
    /**
     * 是否允许翻页
     * @version v1.2.0
     */
    viewerPptTurningEnabled: boolean;
}

declare class DocSocketService {
    protected _docModule: PlvDocModule;
    private __getDocCtrl;
    /** 缓存中的 socket */
    private __cacheSockets;
    /** 缓存最新的 LatestSliceData，才能中途重建 ppt */
    private __latestSliceData;
    private __getDrawMark;
    setLatestSliceData(socketData: WhiteBoardSdkTypes.SocketType): void;
    constructor(_docModule: PlvDocModule, __getDocCtrl: () => DocControlImp | undefined);
    bindChatEvents(): void;
    unbindChatEvents(): void;
    bindSocketEvents(): void;
    unbindSocketEvents(): void;
    /** 处理讲师授权 */
    private __handleSetPermission;
    private __handleOnSliceId;
    /** 处理 socket 消息 */
    private __handleSocketEvent;
    private __handleTransmit;
    /**
     * 插入 socketData 到观看服务中
     */
    private __pushSockets;
    /**
     * 将缓存中的 socket 插入到观看服务中
     */
    pushCacheSockets(): void;
    /**
     * 清空缓存中的 socket
     */
    clearCacheSockets(): void;
}

/**
 * 域名配置对象类型
 */
export declare interface DomainInfo extends VodDomainInfo, WebSdkDomainInfo {
    /**
     * 当前观看页域名
     * @version v1.1.0
     * @default https://live.polyv.cn
     */
    watchPageDomain: string;
    /**
     * V2 观看接口 api 域名
     * @default https://live.polyv.cn
     */
    watchApiDomain: string;
    /**
     * 后台 api 域名
     * @internal
     * @ignore
     * @default https://live.polyv.net
     */
    backstageApiDomain: string;
    /**
     * 直播 api 域名
     * @internal
     * @ignore
     * @default https://live.polyv.net
     */
    liveApiDomain: string;
    /**
     * polyv api 相关接口域名
     * @default https://api.polyv.net
     */
    polyvApiDomain: string;
    /**
     * 观看页 api 接口域名
     * @default https://watch-api.polyv.cn
     */
    polyvWatchApiDomain: string;
    /**
     * normal api 接口域名
     * @default https://live-normal.polyv.net
     */
    normalApiDomain: string;
    /**
     * rtas 采集域名
     * @default https://rtas.videocc.net
     */
    rtasDomain: string;
    /**
     * rtas 采集域名-备用
     * @internal
     * @ignore
     * @default https://rtas-2.videocc.net
     */
    rtasDomain2: string;
    /**
     * elog 采集域名
     * @internal
     * @ignore
     * @default https://elog.polyv.net
     */
    elogDomain: string;
    /**
     * 聊天室 websocket 域名
     * @default https://chat.polyv.net
     */
    chatWsDomain: string;
    /**
     * 聊天室 api 域名
     * @default https://apichat.polyv.net
     */
    chatApiDomain: string;
    /**
     * 静态域名
     * @internal
     * @ignore
     * @default https://liveimages.videocc.net
     */
    staticDomain: string;
    /**
     * 资源域名
     * @internal
     * @ignore
     * @default https://s1.videocc.net
     */
    resourceDomain: string;
    /**
     * 播放器基础域名
     * @internal
     * @ignore
     * @default https://player.polyv.net
     */
    playerBasicDomain: string;
    /**
     * 直播 json 域名
     * @internal
     * @ignore
     * @default https://livejson.polyv.net
     */
    liveJsonDomain: string;
}

/**
 * 域名信息
 */
declare interface DomainInfo_2 {
    /**
     * 观看页域名
     * @default https://live.polyv.cn
     */
    watchPageDomain?: string;
    /**
     * 后台 api 域名
     * @default https://live.polyv.net
     */
    backstageApiDomain?: string;
    /**
     * 直播 api 域名
     * @default https://api.polyv.net
     */
    polyvApiDomain?: string;
    /**
     * 聊天室 api 域名
     * @default https://apichat.polyv.net
     */
    chatApiDomain?: string;
    /**
     * 静态域名
     * @default https://liveimages.videocc.net
     */
    staticDomain?: string;
}

/**
 * 域名配置对象类型
 */
declare interface DomainInfo_3 extends PolyvDomainInfo {
    /**
     * 观看页 api 接口域名
     * @default https://watch-api.polyv.cn
     */
    polyvWatchApiDomain: string;
}

/**
 * @file 请求相关的类型定义
 */
/**
 * 域名配置对象类型
 */
declare interface DomainInfo_4 {
    /**
     * 观看页 api 接口域名
     * @default https://watch-api.polyv.cn
     */
    polyvWatchApiDomain: string;
    /**
     * 观看页域名
     * @default https://live.polyv.cn
     */
    watchPageDomain: string;
}

/**
 * 域名模块
 * @class
 */
declare class DomainModule extends ModuleBase_3 {
    /** 默认的域名 */
    static generateDefaultDomainInfo: () => DomainInfo_4;
    /** 入参的域名信息 */
    private __optionDomainInfo;
    /** detail 中的域名信息 */
    private __detailDomainInfo;
    /** 获取全局注入的域名配置 */
    private __getWindowInjectDomainInfo;
    /**
     * 更新应用配置
     * @description 更新域名配置信息
     * @param {Partial<OmitAppConfig>} appConfig 应用配置
     */
    updateAppConfig(appConfig: Partial<OmitAppConfig_3>): void;
    /**
     * 获取域名信息
     * @description 获取当前配置的域名信息，包括API域名和观看页域名
     * @returns 域名信息对象
     */
    getDomainInfo(): DomainInfo_4;
}

/**
 * @file 打赏相关的类型定义
 */

/** 打赏配置 */
export declare interface DonateConfig {
    /** 现金打赏最低限制 */
    donateCashMin: number;
    /** 现金打赏金额列表 */
    donateCashQuickOptions: number[];
    /** 现金打赏开关 */
    donateCashEnabled: boolean;
    /** 道具（现金）打赏开关 */
    donateGoodEnabled: boolean;
    /** 道具（积分）打赏开关 */
    donatePointEnabled: boolean;
    /** 积分礼物单位 */
    donatePointUnit: string;
    /** 积分单位 */
    donateScoreUnit: string;
}

/**
 * 道具打赏的基础信息
 */
export declare interface DonateGoodBasicData {
    /** 道具开关 */
    goodEnabled: YN;
    /** 道具图片 */
    goodImg: string;
    /** 道具名称 */
    goodName: string;
    /** 道具价格/积分 */
    goodPrice: number;
    /** 特效图片地址 */
    dynamicImg?: string;
    /** 特效文件地址 */
    dynamicFile?: string;
}

/**
 * 道具打赏的信息
 */
export declare interface DonateGoodData extends DonateGoodBasicData {
    /** 道具 id */
    goodId: string;
    /** 道具图片（含动效数据的图片） */
    goodImage: string;
}

/** 打赏支付状态数据 */
export declare interface DonatePayStatusData {
    /** 是否支付成功 */
    paySuccess: boolean;
}

/**
 * @file 打赏相关的枚举
 */
export declare enum DonateType {
    /** 现金打赏 */
    Cash = "cash",
    /** 礼物打赏（包含现金礼物和积分礼物） */
    Good = "good"
}

/**
 * 下行网络质量级别
 */
export declare type DownlinkNetworkQuality = 0 | 1 | 2 | 3 | 4 | 5 | 6;

/**
 * 观看时长抽奖条件
 */
declare interface DurationCondition extends LotteryConditionBase<LotteryCondition.Duration> {
    /**
     * 观看时长，单位：分钟
     */
    duration: number;
    /**
     * 观看时长，单位：秒
     */
    durationSecond: number;
    /**
     * 已观看时长，单位：秒
     */
    watchSecond: number;
    /**
     * 剩余时长，单位：秒
     */
    surplusSecond: number;
}

/**
 * 情绪反馈类型
 */
export declare enum EmotionalFeedbackType {
    /** 没听懂 */
    No = 0,
    /** 明白了 */
    Yes = 1
}

/**
 * 表情图片数据
 */
export declare interface EmotionImageData {
    /**
     * id
     */
    id: string;
    /**
     * 名称
     */
    title: string;
    /**
     * 在线图片地址
     */
    url: string;
}

export declare interface EmotionImageSocketCallback {
    /** 状态 */
    status: 'success';
    data: {
        /** 消息 id */
        messageId: string;
    };
}

/**
 * 报名观看验证类型
 */
export declare enum EnrollAuthType {
    /** 手机号 */
    Mobile = "mobile",
    /** 邮箱 */
    Email = "email"
}

/** 报名观看事件 */
export declare enum EnrollEvents {
    /** 聊天室 SDK 实例改变 */
    EnrollStoreInfoChanged = "EnrollStoreInfoChanged"
}

export declare type EnrollEventsRelations = {
    [EnrollEvents.EnrollStoreInfoChanged]: {
        enrollInfo: EnrollModuleInfo;
    };
};

/**
 * 报名观看表单字段
 */
export declare type EnrollFieldItem = EnrollFieldItemMobile | EnrollFieldItemName | EnrollFieldItemEmail | EnrollFieldItemText | EnrollFieldItemRadio | EnrollFieldItemCheckbox | EnrollFieldItemArea | EnrollFieldItemUpload | EnrollFieldItemPrivacy | EnrollFieldItemTips;

/**
 * 报名观看表单字段：地域
 */
export declare type EnrollFieldItemArea = EnrollFieldItemCommon<EnrollFieldType.Area>;

/**
 * 报名观看表单字段：多选
 */
export declare interface EnrollFieldItemCheckbox extends EnrollFieldItemCommon<EnrollFieldType.Checkbox> {
    /** 选项列表，json 字符 */
    options: string;
    /** 多选项列表（sdk 处理后新增） */
    checkboxOptions: string[];
}

/**
 * 报名观看表单公用字段
 */
export declare interface EnrollFieldItemCommon<T extends EnrollFieldType> {
    /** 字段 id 标识 */
    id: number;
    /** 字段 id 标识（sdk 处理后新增） */
    fieldId: string;
    /** 字段类型 */
    type: T;
    /** 是否必填 */
    required: YN;
    /** 是否必填（sdk 处理后新增） */
    isRequired: boolean;
    /** 排序 */
    rank: number;
    /** 标题 */
    name: string;
    /** 描述 */
    tips: string;
}

/**
 * 报名观看表单字段：邮箱
 */
export declare type EnrollFieldItemEmail = EnrollFieldItemCommon<EnrollFieldType.Email>;

/**
 * 报名观看表单字段：手机号
 */
export declare interface EnrollFieldItemMobile extends EnrollFieldItemCommon<EnrollFieldType.Mobile> {
    /** 验证类型 */
    authType: EnrollAuthType | null;
    /** 是否需要短信验证 */
    smsCheck: YN;
    /** 是否需要填写区号 */
    showAreaCodeEnabled: YN;
}

/**
 * 报名观看表单字段：姓名
 */
export declare type EnrollFieldItemName = EnrollFieldItemCommon<EnrollFieldType.Name>;

/**
 * 报名观看表单字段：隐私声明
 */
export declare type EnrollFieldItemPrivacy = EnrollFieldItemCommon<EnrollFieldType.Privacy>;

/**
 * 报名观看表单字段：单选
 */
export declare interface EnrollFieldItemRadio extends EnrollFieldItemCommon<EnrollFieldType.Radio> {
    /** 选项列表，json 字符 */
    options: string;
    /** 单选项列表（sdk 处理后新增） */
    radioOptions: string[];
}

/**
 * 报名观看表单字段：填空
 */
export declare type EnrollFieldItemText = EnrollFieldItemCommon<EnrollFieldType.Text>;

/**
 * 报名观看表单字段：文本
 */
export declare type EnrollFieldItemTips = EnrollFieldItemCommon<EnrollFieldType.Tips>;

/**
 * 报名观看表单字段：上传图片
 */
export declare interface EnrollFieldItemUpload extends EnrollFieldItemCommon<EnrollFieldType.Upload> {
    /** 上传数量列表，json 字符 */
    options: string;
    /** 需要上传的数量（sdk 处理后新增） */
    uploadCount: number;
}

/**
 * 报名观看表单字段类型
 */
export declare enum EnrollFieldType {
    /** 手机号 */
    Mobile = "mobile",
    /** 姓名 */
    Name = "name",
    /** 邮箱 */
    Email = "email",
    /** 填空 */
    Text = "text",
    /** 单选 */
    Radio = "radio",
    /** 多选 */
    Checkbox = "checkbox",
    /** 地域 */
    Area = "area",
    /** 上传图片 */
    Upload = "upload",
    /** 隐私声明 */
    Privacy = "privacy",
    /** 文本 */
    Tips = "tips"
}

/**
 * 报名观看填写时机
 */
export declare enum EnrollFillTime {
    /** 进入直播时 */
    BeforeEnter = "beforeEnter",
    /** 参与互动时 */
    BeforeChat = "beforeChat"
}

/**
 * 报名观看表单主体类型
 */
export declare type EnrollFormContent = Record<string, string | string[]>;

export declare interface EnrollModuleInfo {
    /** 报名观看开关 */
    enrollEnabled: boolean;
    /** 报名观看审核开关 */
    auditEnabled: boolean;
    /** 是否有报名信息 */
    hasEnrolled: boolean;
    /** 是否已审核通过 */
    hasAudited: boolean;
    /** 填写时机 */
    fillTime: EnrollFillTime;
    /** 入口文本 */
    entranceText: string;
    /** 报名观看标题 */
    enrollTitle: string;
    /** banner 头部图 */
    enrollBanner: string;
    /** 报名观看表单字段列表 */
    enrollFields: EnrollFieldItem[];
    /** 报名观看验证方式 */
    enrollAuthType: EnrollAuthType;
    /** 是否需要短信验证 */
    smsVerifyEnabled: boolean;
    /** 是否需要填写手机区号 */
    areaCodeEnabled: boolean;
    /** 是否使用报名观看姓名作为昵称 */
    enrollNickEnabled: boolean;
}

/**
 * 提交报名观看表单结果
 */
export declare interface EnrollResultData {
    /** 报名审核开关 */
    auditEnabled: boolean;
    /** 是否已审核通过 */
    hasAudited: boolean;
    /** 是否有报名信息 */
    hasEnrolled: boolean;
}

export declare interface EnrollStatusResult {
    /** 审核开关 */
    auditEnabled: YN;
    /** 是否已审核通过 */
    hasAudited: YN;
    /** 是否已有报名记录 */
    hasEnroll: YN;
}

declare interface EnsureWxAuthOptions extends RedirectWeixinAuthorizeUrlOptions_2 {
    /** 由宿主传入的环境探测函数，避免 SDK 直接耦合 UA/运行环境判断逻辑 */
    getIsWeixin?: () => boolean;
    getIsWorkWeixinAuthorized?: () => boolean;
}

declare type EventHandler = (msg: any) => unknown;

declare type EventKey = string;

/**
 * 额外的信息
 */
export declare interface ExtBusinessInfo {
    /** 信息流页面Id */
    infoFeedFlowPageId?: string;
    [key: string]: unknown;
}

/**
 * 额外的信息
 */
declare interface ExtBusinessInfo_2 {
    /** 信息流页面Id */
    infoFeedFlowPageId?: string;
    [key: string]: unknown;
}

/**
 * 外部授权失败地址数据
 */
export declare interface ExternalAuthFailUrlData {
    /**
     * 外部授权失败跳转地址
     */
    externalAuthFailUrl: string | undefined;
}

/**
 * 外部授权签名参数
 */
export declare interface ExternalAuthSignParams extends CommonSpecialAuthSignParams {
}

/**
 * 前后摄像头模式
 */
export declare enum FacingMode {
    /**
     * 前置摄像头
     */
    User = "user",
    /**
     * 后置摄像头
     */
    Environment = "environment"
}

/**
 * 填空题内容
 */
declare interface FillPartData {
    /** 是否为填空 */
    isBlank: boolean;
    /** 填空索引 */
    blankIndex: number;
    /** 非填空时的文本 */
    text: string;
}

/**
 * 填空题数据
 */
declare interface FillQuestionData {
    /** 填空数量 */
    blankCount: number;
    /** 题目内容 */
    partList: FillPartData[];
}

/** 风险确认函-协议 */
export declare interface FinanceRiskConfirmAgreement {
    /** 协议名称 */
    agreementTitle: string;
    /** 协议类型 */
    agreementType: 'upload' | 'link';
    /** 协议链接 */
    agreementUrl: string;
}

/** 风险确认函-确认条件类型 */
export declare enum FinanceRiskConfirmConditionType {
    /** 直接进入 */
    DIRECT = "direct",
    /** 阅读全部 */
    ALL = "all",
    /** 阅读n秒 */
    PART = "part"
}

/** 风险确认函信息 */
export declare interface FinanceRiskConfirmInfo {
    /** 观众确认状态 */
    confirmStatus: boolean;
    /** 弹窗标题 */
    popupTitle: string;
    /** 直播间名称  */
    channelName: string;
    /** 风险确认函内容 */
    content: string;
    /** 需要等待阅读的秒数 */
    readSeconds: number;
    /** 确认条件类型 */
    confirmConditionType: FinanceRiskConfirmConditionType;
}

export declare interface FinanceRiskConfirmSetting {
    /** 是否展示风险确认函 */
    riskConfirmEnabled: YN;
    /** 观众确认状态 */
    riskConfirmStatus: boolean;
}

/** 风险测评 */
export declare interface FinanceRiskEvaluation {
    /** 功能开关（Y/N） */
    evaluationEnabled: YN;
    /** 风险测评问卷id */
    questionnaireId: string;
    /** 风险测评条件 */
    evaluationLimitType: FinanceRiskEvaluationLimitType;
    /** 风险测评分数限制 */
    scoreLimit: number;
    /** 观众测评得分（-1为未测评） */
    score: number;
    /** 通过直播间风险测评条件（1：通过，0：不通过）,注意，当 evaluationLimitType === EvaluationLimitType.Pendant 时，默认为 1  */
    passEvaluation: 1 | 0;
}

/** 金融风险测评事件 */
export declare enum FinanceRiskEvaluationEvents {
    /** 金融风险测评-重置 */
    Reset = "FinanceRiskEvaluationReset"
}

export declare type FinanceRiskEvaluationEventsRelations = {
    [FinanceRiskEvaluationEvents.Reset]: {
        socketData: FinanceRiskEvaluationSocketType;
    };
};

/** 风险测评条件，前置条件需要展示引导页 */
export declare enum FinanceRiskEvaluationLimitType {
    /** 后置条件：默认显示挂件，不自动弹窗 */
    Pendant = 1,
    /** 后置条件：显示挂件，观看5分钟后，自动弹出测评，完成后才可继续观看 */
    PopUp = 2,
    /** 前置条件：完成测评才可进入直播间，无挂件 */
    Evaluation = 3,
    /** 前置条件：需要达到一定测评等级，才可进入直播间，无挂件 */
    EvaluationScoreLimit = 4
}

/** 风险测评 Socket 返回的数据结构 */
export declare interface FinanceRiskEvaluationSocketData {
    /** 目前只有一个 "RESET" 事件 */
    EVENT: 'RESET';
    /** 功能开关（Y/N） */
    evaluationEnabled: YN;
    /** 风险测评分数限制  */
    scoreLimit: number;
    /** 风险测评条件 */
    evaluationLimitType: FinanceRiskEvaluationLimitType;
}

/**
 * 风险测评 socket 消息
 * */
declare type FinanceRiskEvaluationSocketType = FinanceRiskEvaluationSocketData;

/**
 * 将服务端的答案格式化题目答案
 * @param answer 答案，如：a、A、AB、a,b,c
 * @param type 题目类型
 * @returns 格式化后的答案
 */
declare function formatQuestionAnswer(answer: string, type: QuestionItemType): QuestionAnswerType | undefined;

/**
 * 全屏方案
 */
export declare enum FullScreenMode {
    /**
     * 系统全屏
     */
    System = "system",
    /**
     * 网页全屏
     */
    WebHtml = "webHtml"
}

/**
 * 默认的红包祝福语
 */
export declare const geDefaultRedpackGreeting: () => string;

export declare function generateDefaultAccountInfo(): AccountInfo;

/**
 * 生成默认的连麦信息
 */
export declare const generateDefaultConnectMicInfo: () => ConnectMicStoreInfo;

/**
 * 生成默认的连麦网络信息
 */
export declare const generateDefaultNetworkInfo: () => ConnectMicNetworkInfo;

/**
 * 生成默认的屏幕共享信息
 */
export declare const generateDefaultScreenShareInfo: () => ScreenShareInfo;

export declare interface GeneratePosterUrlOptions {
    /**
     * 设置云席信息
     * @default false
     */
    setSeatTable?: boolean;
    /**
     * 云席行数
     */
    seatTableRow?: number;
    /**
     * 云席列数
     */
    seatTableColumn?: number;
}

/** 手势 seek 方向 */
export declare type GestureSeekDirection = 'vertical' | 'horizontal';

export declare interface GetAnchorChannelListParams {
    pageNumber?: number;
    pageSize?: number;
}

export declare interface GetAskHistoryParamsNew {
    /**
     * 查询的观众 Id
     */
    userId?: string;
    /**
     * 页数
     * @default 1
     */
    pageNumber?: number;
    /**
     * 每页数量
     * @default 10
     */
    pageSize?: number;
}

export declare interface GetChannelFileListParams {
    pageSize?: number;
    pageNumber?: number;
}

export declare interface GetChannelFileListRequest {
    channelId: string;
    userId: string;
    size?: number;
    page?: number;
}

export declare interface GetChannelFileListResponse extends ChatListResponse {
    list: ChannelFileListItem[];
}

/** 获取频道号参数 */
export declare type GetChannelIdOptions = {
    /** 判断双师情况，默认：false */
    judgeTransmitDouble?: boolean;
};

declare interface GetChannelMenuDataParams {
    /** 资源 id */
    sourceId: string;
    /** 菜单 id */
    menuId: string;
}

export declare interface GetChannelSessionListParams {
    pageNumber?: number;
    pageSize?: number;
    status?: string;
    order?: string;
}

/** 获取频道直播流参数 */
export declare type GetChannelStreamOptions = {
    /** 判断测试模式，优先级最高，默认：false */
    judgeDebugModel?: boolean;
    /** 判断双师情况，默认：false */
    judgeTransmitDouble?: boolean;
};

/**
 * getChatHistoryBySessionId 调用参数选项
 */
export declare interface GetChatHistoryBySessionIdOptions {
    /**
     * 场次 Id
     */
    sessionId: string;
    /**
     * 页数
     * @default 1
     */
    pageNumber?: number;
    /**
     * 每页数量
     * @default 10
     */
    pageSize?: number;
}

export declare interface GetChatHistoryByTimeOptions {
    /**
     * 时间戳
     */
    timestamp?: number;
    /**
     * 时间戳相对应的数量
     * @default 1
     */
    count?: number;
    /**
     * 获取的数量
     * @default 10
     */
    size?: number;
    /**
     * 排除的消息类型
     */
    exclude?: Array<ChatMsgSource | string>;
    /**
     * 是否校验"排除的消息类型"
     * @version v1.7.0
     * @default true
     */
    validateExcludeMsgSource?: boolean;
    /**
     * 聊天请求历史数据模式
     * @desc 默认是请求上一页数据
     */
    mode?: ChatRequestHistoryMode;
    /**
     * 是否只获取特殊身份消息
     * @default false
     */
    onlySpecialMsg?: boolean;
}

/**
 * getChatHistory 调用参数选项
 */
export declare interface GetChatHistoryOptions {
    /**
     * 消息起始索引
     * @default 0
     */
    start?: number;
    /**
     * 消息终止索引
     * @default 9
     */
    end?: number;
    /**
     * 是否仅获取特殊角色发言
     * @default false
     */
    onlySpecialMsg?: boolean;
    /**
     * 是否过滤自定义消息
     * @version v0.10.0
     * @default true
     */
    filterCustomMsg?: boolean;
    /**
     * 是否过滤红包信息
     * @version v1.7.0
     * @default false
     */
    filterRedpaperMsg?: boolean;
}

/** 获取聊天消息分段详情(具体聊天消息)请求 */
export declare namespace GetChatReplayMsgPartDetailRequest {
    export interface ResponseData {
        list: ChatApiReplayMsgType[];
    }
}

/** 获取聊天消息分段列表请求 */
export declare namespace GetChatReplayMsgPartListRequest {
    export interface ResponseData {
        partDetail: ChatReplayMsgPart[];
        total: number;
        totalPage: number;
    }
}

declare interface GetCheckInRecordResponse {
    checkInFinished: boolean;
    checkInRecordData: Array<Omit<CheckInRecordData_2, 'checked' | 'checkinId'> & {
        checked: boolean;
        checkInId: string;
    }>;
}

export declare namespace GetCustomAuthUrlRequest {
    export interface RequestParams {
        /** 重定向地址 */
        redirectUri: string;
    }
    export interface ResponseData {
        /** 令牌 */
        token: string;
        /** 跳转地址 */
        url: string;
    }
}

/**
 * 判断账号是否有报名记录
 */
export declare interface GetEnrollStatusParams {
    /** 验证手机号，authType 为 mobile 时必传 */
    phoneNumber?: string;
    /** 手机区号 */
    areaCode?: string;
    /** 验证邮箱，authType 为 email 时必传 */
    email?: string;
}

export declare interface getExtBusinessPropType {
    /**
     * 获取其他业务信息
     */
    getExtBusinessInfo?: MaybePromise<ExtBusinessInfo>;
}

export declare interface GetFullMsgSocketCallback {
    /** 状态 */
    code: number;
    data: {
        /** 消息内容 */
        content: string;
    };
}

declare interface GetGoogleAuthorizeRedirectUrlOptions {
    /** 授权成功后重定向的地址，默认使用当前地址 */
    callbackRedirectUrl?: string;
}

export declare interface GetInviteDetailListParams {
    /** 当前页数，默认：1 */
    pageNumber?: number;
    /** 每页数量，默认：40 */
    pageSize?: number;
}

/** 获取直播打点请求 */
declare namespace GetLiveTimeAxisMarkListRequest {
    interface RequestData extends TimeAxisMarkQueryParam {
        viewerId: string;
    }
    type ResponseData = TimeAxisMarkOriginInfo[];
}

declare interface GetLotteryViewerSizeOptions {
    /**
     * 抽奖 id
     */
    lotteryId: string;
    /**
     * 抽奖条件
     */
    lotteryCondition: LotteryCondition;
    /**
     * 问卷 id
     */
    questionnaireId?: string;
}

declare interface GetLotteryWinnersOptions extends PageOptions {
    /**
     * 抽奖 id
     */
    lotteryId: string;
    /**
     * 分组 id
     */
    groupId?: number;
}

export declare interface GetMultiMeetingListOptions {
    /** 页数，默认：1 */
    pageNumber?: number;
    /** 每页大小，默认：10 */
    pageSize?: number;
}

export declare namespace GetPayDataRequest {
    export interface ResponseData {
        /** 二维码内容 */
        codeUrl: string;
        /** 支付 id */
        payId: string;
        appId?: string;
        nonceStr?: string;
        prepayId?: string;
        paySign?: string;
        signType?: string;
        timeStamp?: string;
    }
}

/**
 * 获取回放列表
 */
export declare interface GetPlaybackListParams {
    /** 页数，默认：1 */
    pageNumber?: number;
    /** 每页数量，默认：10 */
    pageSize?: number;
    /** 关键词搜索 */
    keyword?: string;
}

/** 获取回放打点请求 */
declare namespace GetPlaybackTimeAxisMarkListRequest {
    interface RequestData extends TimeAxisMarkQueryParam {
        viewerId: string;
    }
    type ResponseData = TimeAxisMarkOriginInfo[];
}

/**
 * 获取题目默认答案
 * @param question 题目数据
 * @returns 默认答案
 */
declare function getQuestionDefaultAnswer(question: QuestionItem): QuestionAnswerType;

/**
 * 获取邀请榜参数
 */
export declare interface GetRankListParams {
    /** 当前页数，默认：1 */
    pageNumber?: number;
    /** 每页数量，默认：100 */
    pageSize?: number;
}

/**
 * 获取红包领取记录参数
 */
export declare interface GetRedpackReceiveRecordParams {
    /** 页数，默认：1 */
    pageNumber?: number;
    /** 每页数量，默认：10 */
    pageSize?: number;
    /** 红包支付类型 */
    redPackType?: RedpackPayType;
}

/**
 * 获取用于提交请求答案
 * @param data 提交答案数据
 * @returns 请求答案
 */
declare function getRequestAnswer(data: SubmitAnswerData): string;

export declare interface GetSubtitlesHistoryList {
    /**
     * 从第几位开启请求
     */
    index?: number;
    /**
     * 每页的大小，默认10
     */
    size?: number;
    /**
     * 1表示升序,-1表示降序
     */
    order?: number;
}

/**
 * 获取字幕默认名称（原声字幕）
 */
export declare const getSubtitleSourceName: () => string;

/**
 * 获取字幕默认名称（翻译字幕）
 */
export declare const getSubtitleTranslateName: () => string;

export declare interface GetTaskRewardListOptions {
    pageNumber?: number;
    pageSize?: number;
}

declare interface GetViewerLabelListOptions extends PageOptions {
    /**
     * 搜索关键词
     */
    keyword?: string;
}

export declare namespace GetWechatPayCheckDataRequest {
    export interface ResponseData {
        /** 记录 id */
        logId: string;
        /** 二维码 & 请求地址 */
        url: string;
    }
}

export declare interface GetWeixinAuthorizeRedirectUrlOptions {
    /** 是否使用静默授权，默认：true */
    snsApiBase?: boolean;
    /** 授权成功后重定向的地址，默认使用当前地址 */
    callbackRedirectUrl?: string;
}

declare interface GetWeixinAuthorizeRedirectUrlOptions_2 {
    /** 是否使用静默授权，默认：true */
    snsApiBase?: boolean;
    /** 忽略已授权信息重新授权，默认：false */
    reload?: boolean;
    /** 授权成功后重定向的地址，默认使用当前地址 */
    callbackRedirectUrl?: string;
    /** 是否需要判断长时间授权态 */
    persistentAuth?: boolean;
}

/** 获取微信签名数据入参 */
export declare interface GetWeixinSignParams {
    /** 频道号 */
    channelId: string;
    ts: number;
    sign: string;
    url: string;
}

/**
 * 获取提现记录参数
 */
export declare interface GetWithdrawRecordParams {
    /** 当前页数，默认：1 */
    pageNumber?: number;
    /** 每页数量，默认：10 */
    pageSize?: number;
}

export declare interface GetWorkWeixinAuthorizeCodeOptions {
    /** 授权成功后重定向的地址，默认使用当前地址 */
    callbackRedirectUrl?: string;
}

declare interface GetWorkWeixinAuthorizeCodeOptions_2 {
    /** 授权成功后重定向的地址，默认使用当前地址 */
    callbackRedirectUrl?: string;
}

/**
 * 用户配置
 */
export declare interface GlobalUserConfig {
    /** 个人中心-聚合页页面Id */
    personalCenterPageId: string;
    /** 任务奖励统计方式 */
    taskRewardStatsByPlayerEnabled: YN;
    /** 客户账号状态 */
    userStatus: 'CLOSED' | 'NORMAL';
    /** 客户是否绑定企业微信（后台开关） */
    weixinWorkStatus: YN;
}

/**
 * Google 授权信息（后端接口返回）
 */
declare interface GoogleAuthRedirectUrlData {
    /** 授权成功后的回调地址 */
    redirectUrl: string;
    /** 回调参数 */
    state: string;
    /** Google 应用 id */
    webClientId: string;
}

/**
 * Google 登录模块
 * @class
 */
declare class GoogleModule extends ModuleBase_3 {
    private __gsiLoaded;
    private __gsiLoading;
    private __oidcInitialized;
    /**
     * 动态加载 Google Identity Services SDK
     * @description 只在需要时加载，避免影响初始页面性能
     */
    loadGsiSdk(): Promise<void>;
    /**
     * 获取 Google 授权信息
     * @description 调用后端接口获取 webClientId、redirectUrl、state
     */
    getGoogleAuthInfo(options?: GetGoogleAuthorizeRedirectUrlOptions): Promise<GoogleAuthRedirectUrlData>;
    /**
     * 初始化 OIDC 配置（设置 credential 回调）
     */
    private __initializeOidc;
    /**
     * 在指定容器中渲染 Google 官方登录按钮
     * @description 用户点击按钮后通过弹窗完成登录，credential 通过 initialize 回调返回
     */
    renderGoogleButton(container: HTMLElement): void;
    /**
     * 准备并渲染 Google 登录按钮（加载 SDK → 获取授权信息 → 初始化 OIDC → 渲染按钮）
     */
    prepareAndRenderButton(container: HTMLElement, options?: GetGoogleAuthorizeRedirectUrlOptions): Promise<void>;
}

/** 头部广告 */
export declare type HeadAdvertSetting = {
    /** 广告持续时间 */
    headAdvertDuration: number;
    /** 广告开关 */
    headAdvertEnabled: YN;
    /** 广告通用链接 */
    headAdvertHref: string;
    /** 广告链接类型 */
    headHrefType: AdvertHrefType;
    /** 移动端链接 */
    headMobileLink: string;
    /** PC端链接 */
    headPcLink: string;
    /** PC 跳转方式 */
    headPcLinkJumpWay: LinkJumpWay;
    /** 微信小程序appId */
    headWxMiniprogramAppId: string;
    /** 微信小程序链接 */
    headWxMiniprogramLink: string;
    /** 微信小程序原始id */
    headWxMiniprogramOriginalId: string;
    /** 跳转方式 */
    headJumpWay: LinkJumpWay;
    /** 移动端app跳转链接 */
    headMobileAppLink: string;
    /** 移动端 app 跳转方式 */
    headMobileAppLinkJumpWay: LinkJumpWay;
    /** iOS 跳转链接 */
    headIosLink: string;
    /** 安卓跳转链接 */
    headAndroidLink: string;
    /** 鸿蒙跳转链接 */
    headHarmonyLink: string;
};

export declare interface HxcGeneralIframeEventData {
    type: MicroActivityIframeEventType.HXC_ONLY_MOBILE | MicroActivityIframeEventType.HXC_BACK_HOME | MicroActivityIframeEventType.HXC_FULL_SCREEN | MicroActivityIframeEventType.HXC_FORCE_FULL_SCREEN | MicroActivityIframeEventType.HXC_RESTORE_DEFAULT | MicroActivityIframeEventType.HXC_DISABLE_PAGE_SCROLL;
    data: {
        name: string;
        title: string;
    };
}

/** 子级 iframe postMessage 事件消息 */
export declare type HxcIframeEventData = HxcGeneralIframeEventData | HxcRequestDevicePermissionIframeEventData;

export declare interface HxcRequestDevicePermissionIframeEventData {
    type: MicroActivityIframeEventType.HXC_REQUEST_DEVICE_PERMISSION;
    data: {
        enable: boolean;
    };
}

export { IarAddressManagement }

export { IarAnnouncement }

export { IarAnswerCard }

/** 答题卡普通题目类型 */
export declare enum IarAnswerQuestionTypes {
    /** 多选 */
    CheckBox = "C",
    /** 单选 */
    Radio = "R",
    /** 评分题 */
    Score = "S",
    /** 投票题 */
    Vote = "V"
}

declare type IarAppName = keyof IarAppRelations;

declare type IarAppPkg<N extends IarAppName> = IarAppRelations[N]['Pkg'];

declare type IarAppRelations = {
    'interaction-core': {
        globalKey: 'PolyvInteractionCore';
        Ctor: typeof PolyvInteractionCore.InteractionCore;
        Pkg: typeof PolyvInteractionCore;
    };
    'answer-card': {
        globalKey: 'PolyvAnswerCardSdk';
        Ctor: typeof PolyvAnswerCard.AnswerCard;
        Pkg: typeof PolyvAnswerCard;
    };
    questionnaire: {
        globalKey: 'PolyvQuestionnaireSdk';
        Ctor: typeof PolyvQuestionnaire.Questionnaire;
        Pkg: typeof PolyvQuestionnaire;
    };
    'check-in': {
        globalKey: 'PolyvCheckInSdk';
        Ctor: typeof PolyvCheckIn.CheckIn;
        Pkg: typeof PolyvCheckIn;
    };
    lottery: {
        globalKey: 'PolyvLotterySdk';
        Ctor: typeof PolyvLottery.Lottery;
        Pkg: typeof PolyvLottery;
    };
    coupon: {
        globalKey: 'PolyvCouponSdk';
        Ctor: typeof PolyvCoupon.Coupon;
        Pkg: typeof PolyvCoupon;
    };
    'lucky-lottery': {
        globalKey: 'PolyvLuckyLotterySdk';
        Ctor: typeof PolyvLuckyLottery.LuckyLottery;
        Pkg: typeof PolyvLuckyLottery;
    };
    'lucky-bag': {
        globalKey: 'PolyvLuckyBagSdk';
        Ctor: typeof PolyvLuckyBag.LuckyBag;
        Pkg: typeof PolyvLuckyBag;
    };
    vote: {
        globalKey: 'PolyvVoteSdk';
        Ctor: typeof PolyvVote.Vote;
        Pkg: typeof PolyvVote;
    };
    bulletin: {
        globalKey: 'PolyvBulletinSdk';
        Ctor: typeof PolyvBulletin.Bulletin;
        Pkg: typeof PolyvBulletin;
    };
};

export { IarCheckIn }

export { IarEnrollLottery }

export { IarFeedBack }

export { IarLottery }

/** 抽奖状态枚举 */
export declare enum IarLotteryStatus {
    /** 正在抽奖 */
    running = "running",
    /** 计时中 */
    timing = "timing",
    /** 抽奖结束(未关闭) */
    over = "over",
    /** 抽奖结束(已结束) */
    end = "end"
}

export { IarOrder }

export { IarProduct }

export declare enum IarProductType {
    /** 普通产品 */
    Normal = "normal",
    /** 金融产品 */
    Finance = "finance",
    /** 职业产品 */
    Job = "position"
}

export { IarPushCard }

export { IarQuestionAnswer }

export { IarQuestionnaire }

export { IarRedpack }

export { IarRedpackRain }

declare interface IarReplayAnswerCardMsg {
    /** 透传给聊天室 socket 的请求内容 */
    request: {
        content: UniversalParams<unknown>;
    };
    /** 答题卡问卷Id */
    questionId: string;
    /** 回放操作 */
    operation: 'start' | 'end';
}

declare interface IarReplayCheckInMsg {
    /** 签到id */
    checkinId: string;
    /** 签到持续时间 */
    limitTime: number;
    /** 签到开始时间 */
    createtime: string;
    /** 签到结束时间 */
    endtime: string;
    /** 是否强制签到 */
    forceCheckInEnabled: YN;
    /** 签到提示语 */
    message: string;
    /** 回放操作 */
    operation: 'start' | 'end';
}

declare interface IarReplayPushCardMsg {
    /** 操作 */
    operation: 'add' | 'cancel';
    /** 关联数据 */
    payload: {
        /** 卡片ID */
        id: string;
        /** 剩余显示时长(单位秒) */
        time: number;
        /** 是否有卡片入口，Y表示有入口，N表示没有 */
        entrance: YN;
        /** 等待多久后显示（秒） */
        lookTime: number;
        /**
         * 是否只显示入口
         * @desc 当前只是前端自定义的字段，只用在卡片推送重放中
         */
        onlyShowEntrance?: boolean;
    };
}

declare interface IarReplayQuestionnaireMsg {
    /** 透传给聊天室 socket 的请求内容 */
    request: {
        content: UniversalParams<unknown>;
    };
    /** 问卷Id */
    questionnaireId: string;
    /** 回放操作 */
    operation: 'start' | 'end';
}

export { IarRushAnswer }

declare type IarSdkScriptConfig = Partial<{
    [key in IarAppName]: SdkLoaderScriptType;
}>;

export { IarSeatTable }

export { IarTopicPK }

export { IarTuwen }

export { IarVote }

export { IarWelfareLottery }

/**
 * 图标广告项
 */
export declare type IconAdvertItem = {
    /** 广告id */
    id: number;
    /** 频道id */
    channelId: number;
    /** 广告图片 */
    advertImage: string;
    /** 链接类型 */
    hrefType: string;
    /** 广告链接 */
    advertHref: string;
    /** pc广告链接 */
    pcLink: string;
    /** pc 跳转方式 */
    pcLinkJumpWay: LinkJumpWay;
    /** 移动端广告链接 */
    mobileLink: string;
    /** 微信小程序原始id */
    wxMiniprogramOriginalId: string;
    /** 微信appid */
    wxMiniprogramAppId: string;
    /** 微信小程序页面地址 */
    wxMiniprogramLink: string;
    /** 广告类型 */
    advertType: string;
    /** 跳转方式 */
    jumpWay: LinkJumpWay;
    /** 移动端app跳转链接 */
    mobileAppLink: string;
    /** 移动端 app 链接跳转方式 */
    mobileAppLinkJumpWay: LinkJumpWay;
    /** iOS 跳转链接 */
    iosLink: string;
    /** Android 跳转链接 */
    androidLink: string;
    /** harmony 跳转链接 */
    harmonyLink: string;
};

/**
 * 图标广告
 */
export declare type IconAdvertSetting = {
    /** 图标广告开关 */
    imgAdvertEnabled: YN;
    /** 图标广告图片 */
    closeImgAdvertEnabled: YN;
    imgAdvertList?: IconAdvertItem[];
};

declare class IdentifyCore {
    /** 域名处理模块 */
    domain: DomainModule;
    /** 短信模块 */
    sms: SmsModule;
    /** 工具模块 */
    utils: UtilsModule;
    /** 身份认证模块 */
    identity: IdentityModule;
    /** 微信模块 */
    weixin: WeixinModule;
    /** Google 登录模块 */
    google: GoogleModule;
    /**
     * 直播观看页 api 请求器
     * @internal
     * @ignore
     */
    polyvWatchApi: PolyvWatchApi;
    /**
     * 基础请求器（无baseUrl）
     * @internal
     * @ignore
     */
    basicApi: ApiQuery;
    /**
     * 配置参数
     */
    private __appConfig;
    /**
     * 获取应用配置
     * @description 返回当前IdentifyCore实例的应用配置，不包括认证来源配置
     * @returns 应用配置对象
     */
    getAppConfig(): Partial<OmitAppConfig_3>;
    /**
     * 认证来源配置
     */
    private __identitySourceConfig;
    /**
     * 设置认证来源配置
     */
    setIdentifySourceConfig(config: IdentitySourceConfig): void;
    /**
     * 获取认证来源类型
     * @description 返回当前设置的认证来源类型，如CHANNEL、AGGREGATE_PAGE、INFO_FLOW
     * @returns 认证来源类型
     */
    getIdentifySourceType(): IdentityInfoSourceType | string;
    /**
     * 获取认证来源Id
     * @description 返回当前设置的认证来源ID，如频道ID、聚合页ID等
     * @returns 认证来源ID
     */
    getIdentifySourceId(): string;
    /**
     * 更新参数配置
     * @description 注意，不支持通过该方法更新认证来源数据
     * @param {Partial<OmitAppConfig>} appConfig 应用配置
     */
    updateAppConfig(appConfig: Partial<OmitAppConfig_3>): void;
    constructor(config?: IdentifyCoreConfig);
    /**
     * 设置授权 token
     * @internal
     * @ignore
     */
    setXAuthToken(xAuthToken: string): void;
    /**
     * 获取授权 token
     * @internal
     * @ignore
     */
    getXAuthToken(): string;
    /**
     * setup 流程
     * @description 需要执行 setup 流程后才能正常获取用户数据，进行用户登录等操作
     * @returns setup完成的Promise
     */
    setup(): Promise<void>;
    /**
     * 销毁流程
     * @description 销毁IdentifyCore实例及其所有模块，释放资源
     */
    destroy(): void;
}

declare interface IdentifyCoreConfig {
    sourceConfig?: IdentitySourceConfig;
    lang?: LangType_2;
    domainInfo?: Partial<DomainInfo_4>;
}

declare enum IdentifyEvents {
    /**
     * 用户登录扫码状态更新
     */
    UserLoginScanStatusUpdate = "UserLoginScanStatusUpdate",
    /**
     * 用户封禁
     */
    UserForbidden = "UserForbidden"
}

/**
 * 保利威 AI 模块事件回调参数配置
 */
declare type IdentifyEventsRelations = {
    [IdentifyEvents.UserLoginScanStatusUpdate]: {
        /** 状态 */
        status: UserLoginScanStatus;
    };
    [IdentifyEvents.UserForbidden]: void;
};

declare enum IdentifyLoginMethod {
    /** 微信登录 */
    Weixin = "weixin",
    /** 手机号登录 */
    Phone = "phone",
    /** 企业微信 */
    WorkWeixin = "work-weixin",
    /** 独立授权登录 */
    Direct = "direct",
    /** Google 登录 */
    Google = "google"
}

/**
 * 身份认证-子模块-基础模块
 */
declare class IdentityBasicModule extends ModuleBase_3 {
    /** 事件触发器 */
    eventEmitter: EventEmitter_2<IdentifyEventsRelations, IdentifyEvents>;
    /**
     * 用户唯一信息
     */
    private __identityUnionInfo?;
    /**
     * 获取用户唯一信息
     * @description 获取当前用户的身份唯一信息，包括手机号、微信信息等
     * @param {boolean} check 是否强制检查数据存在，如果为true且数据不存在则抛出错误
     * @returns 用户身份信息，如果未设置则返回undefined
     */
    getIdentityUnionInfo(check?: false): IdentityUnionInfo | undefined;
    getIdentityUnionInfo(check: true): IdentityUnionInfo;
    /**
     * 更新用户信息
     * @description 更新当前用户的身份信息，会合并到现有信息中
     * @param {Partial<IdentityUnionInfo>} info 要更新的用户信息
     */
    updateIdentityUnionInfo(info: Partial<IdentityUnionInfo>): void;
    /**
     * 设置用户信息
     * @description 将服务器返回的观众信息转换为内部身份信息格式
     * @param {ViewerUnionInfo} info 服务器返回的观众信息
     */
    protected _setIdentityUnionInfo(info: ViewerUnionInfo): void;
    private __viewerDetail?;
    /**
     * 获取观众详情
     * @description 获取当前观众的详细信息，包括身份信息和微信信息
     * @returns 观众详情，如果未设置则返回undefined
     */
    getViewerDetail(): ViewerDetail | undefined;
    private __setupViewerDetail;
    /**
     * 检查当前是否已登录
     * @description 检查用户是否已经完成身份认证登录
     * @returns 是否已登录
     */
    checkIdentityInfoLogin(): Promise<boolean>;
    /**
     * 重新刷新身份认证信息
     * @description 重新从服务器获取用户身份信息并更新本地数据
     * @returns
     */
    refreshIdentityInfo(): Promise<void>;
    /** 用户登录基础配置 */
    private __userLoginBasicConfig?;
    /**
     * 获取用户登录基础配置
     * @description 获取用户登录相关的基础配置，包括登录方式、协议等
     * @returns 用户登录基础配置
     * @throws {Error} 如果在setup之前调用会抛出错误
     */
    getUserLoginBasicConfig(): UserLoginBasicConfig;
    private __setupUserLoginConfig;
    /**
     * 根据短信功能开关过滤登录注册类型, 没有短信功能则移除手机号登录类型
     * */
    private __filterRegisterLoginTypeBySmsEnabled;
    /**
     * 支持的登录方式
     * @description 默认值支持所有授权方式
     */
    private __supportedLoginMethods;
    /**
     * 获取支持的登录方式
     * @description 获取当前支持的登录方式列表
     * @returns 支持的登录方式数组
     */
    getSupportedLoginMethods(): IdentifyLoginMethod[];
    /**
     * 设置对应支持的登录方式
     * @description 应该慎用该方法，优先使用 {@link removeSupportedLoginMethods} 和 {@link keepSupportedLoginMethods}
     */
    setSupportedLoginMethods(methods: IdentifyLoginMethod[]): void;
    /**
     * 移除对应支持的登录方式
     * @description 从支持的登录方式中移除指定的登录方式
     * @param {IdentifyLoginMethod[]} methods 要移除的登录方式数组
     */
    removeSupportedLoginMethods(methods: IdentifyLoginMethod[]): void;
    /**
     * 只保留对应支持的登录方式
     * @description 只保留指定的登录方式，移除其他登录方式。如果当前登录方式有对应的配置才会保留
     * @param {IdentifyLoginMethod[]} methods 要保留的登录方式数组
     */
    keepSupportedLoginMethods(methods: IdentifyLoginMethod[]): void;
    private __setupSupportedLoginMethods;
    private __setupModule;
    /**
     * 确保 setup
     * @description 如果没有数据，则尝试 setup 处理，如果已有数据，则不必处理
     */
    ensureSetup(): Promise<void>;
    /**
     * 核心 setup 钩子
     * @description 执行初始化流程，获取用户配置和观众信息
     * @returns
     */
    setup({ cache }?: {
        cache?: boolean | undefined;
    }): Promise<void>;
    /**
     * 确保用户配置数据存在
     * @description 如果没有数据，则尝试请求接口处理，如果已有数据，则不必处理
     */
    ensureUserLoginConfig(): Promise<void>;
}

export declare type IdentityDirectAuthParams = DirectAuthSignParams_2;

export declare enum IdentityInfoFailReason {
    /** 未知错误 */
    Unknown = "Unknown"
}

declare enum IdentityInfoSourceType {
    /** 聚合页 */
    AggregatePage = "AGGREGATE_PAGE",
    /** 信息流 */
    InfoFlow = "INFO_FLOW",
    /** 频道(直播间) */
    Channel = "CHANNEL"
}

/**
 * 身份认证模块
 */
declare class IdentityModule extends IdentityScanLoginModule {
    /**
     * 检查是否包含企微授权登录方式
     * @description 检查当前支持的登录方式中是否包含企业微信登录
     * @returns 是否支持企业微信登录
     */
    checkWorkWeixinLoginEnabled(): boolean;
    /**
     * 通过手机号登录
     * @description 验证用户系统的手机号授权
     * @param {LoginIdentityInfoParams} params 登录参数，包括手机号、区号、短信验证码
     * @returns 登录结果
     */
    loginIdentityInfo(params?: LoginIdentityInfoParams): Promise<CommonResult_3<IdentityInfoFailReason>>;
    /**
     * 绑定用户信息
     * @description 目前主要用于绑定用户手机号
     * @param {BindIdentityInfoParams} params 绑定参数，包括手机号、区号、短信验证码
     * @returns 绑定结果
     */
    bindIdentityInfo(params?: BindIdentityInfoParams): Promise<CommonResult_3<IdentityInfoFailReason>>;
    /**
     * 是否允许验证独立授权
     * @description 检查独立授权参数是否完整，用于验证前的基本校验
     * @param {DirectAuthSignParams} signParams 独立授权签名参数
     * @returns 是否允许验证独立授权
     */
    allowToVerifyDirectAuth(signParams: DirectAuthSignParams_2): boolean;
    /**
     * 通过独立授权登录
     * @description 验证用户系统的独立授权
     * @param {DirectAuthSignParams} params 独立授权签名参数
     * @returns 验证结果
     */
    verifyDirectAuth(params: DirectAuthSignParams_2): Promise<CommonResult_3<IdentityInfoFailReason>>;
    /**
     * 获取用户登录设置
     * @description 获取用户登录相关的配置信息，包括登录方式、协议等
     * @returns 用户登录配置
     */
    getUserLoginConfig(): Promise<UserLoginConfig>;
    /**
     * 获取用户登录协议信息
     */
    private __getUserAgreementConfig;
    /**
     * 检查是否开启采集信息
     * @description 检查是否需要采集用户手机号信息
     * @returns 是否开启采集信息
     */
    checkCollectEnabled(): Promise<boolean>;
    /**
     * 获取游客外链登录配置
     * @description 获取游客模式下的外链登录配置信息
     * @returns 外链登录配置，如果未配置则返回null
     */
    getIdentifyGuestLinkLoginConfig(): LinkData | null;
    /**
     * @internal
     * @ignore
     */
    triggerIdentityUserForbidden(): void;
}

/**
 * 身份认证-子模块-扫码登录模块
 */
declare class IdentityScanLoginModule extends IdentityBasicModule {
    /** 扫码状态轮询间隔（单位：秒）  */
    private __scanStatusPollingInterval;
    /**
     * 获取登录扫码配置
     * @description 获取用户扫码登录所需的配置信息，包括二维码链接和场景ID
     * @param {string} opts.qrCodeContent 二维码内容，只能为链接
     * @returns 扫码登录配置
     */
    getUserLoginScanConfig(opts?: {
        /** 二维码内容，只能为链接 */
        qrCodeContent: string;
    }): Promise<UserLoginScanConfig>;
    private __scanSceneId;
    /**
     * 设置扫码场景ID
     * @description 设置扫码登录的场景ID，用于后续状态查询
     * @param {string} sceneId 场景ID
     */
    setScanSceneId(sceneId: string): void;
    /**
     * 获取扫码场景ID
     * @description 获取当前设置的扫码场景ID
     * @returns 场景ID，如果未设置则返回undefined
     */
    getScanSceneId(): string | undefined;
    /**
     * 获取扫码状态
     * @description 获取当前扫码登录的状态
     * @returns 当前扫码状态
     */
    private __scanStatus;
    getScanStatus(): UserLoginScanStatus;
    /**
     * 更新登录扫码状态
     */
    private __updateScanStatus;
    /**
     * 扫码状态定时器
     */
    private __scanStatusTimer?;
    /**
     * 停止用户登录扫码状态轮询
     * @description 停止扫码状态的定时轮询
     */
    stopUserLoginScanStatusPolling(): void;
    /**
     * 获取用户登录扫码状态
     * @description 从服务器获取当前扫码登录的状态
     * @returns 当前扫码状态
     */
    fetchUserLoginScanStatus(): Promise<UserLoginScanStatus>;
    /**
     * 开始进行用户登录扫码状态轮询
     * @description 启动定时轮询，持续获取扫码登录状态直到结束
     */
    startUserLoginScanStatusPolling(): void;
    /**
     * 设置用户登录扫码状态
     * @description 设置扫码登录的状态并同步到服务器
     * @param param
     * @returns
     */
    setUserLoginScanStatus({ status }: {
        status: UserLoginScanStatus;
    }): Promise<void>;
}

export declare interface IdentitySetting {
    /**
     * 用户系统开关
     */
    watchUserSystemEnabled: boolean;
    /**
     * "个人中心"开关
     * @version v1.11.0
     */
    profileEnabled: boolean;
}

declare interface IdentitySourceConfig {
    /** 来源 Id */
    id: string;
    /** 来源类型 */
    sourceType: IdentityInfoSourceType | string;
}

export declare interface IdentityUnionInfo {
    /** 手机号 */
    phoneNumber: string;
    /** 唯一 id */
    viewerUnionId: string;
    /** 外部用户 id */
    externalViewerId: string;
    /** 微信昵称 */
    wxNickName: string;
    /** 微信头像 */
    wxAvatar: string;
    /** 微信 openId */
    wxOpenId: string;
    /** 微信 unionId */
    wxUnionId: string;
    /** 昵称 */
    nickname: string;
    /** 用户标签列表 */
    labels: ViewerUnionLabelItem[];
    /** 是否邀请员 */
    isInviteSales: boolean;
    /** 是否邀请员管理员 */
    isInviteSalesAdmin: boolean;
    /** 邀请员所属 ID */
    organizationId: number;
    /** 是否是游客 */
    isGuest: boolean;
}

/**
 * 图片验证码的参数
 */
export declare interface ImageCaptchaParams {
    /** 图片验证码 id */
    imageId: string;
    /** 图片验证码 */
    imageCaptcha: string;
}

/**
 * 图片验证码的参数
 */
declare interface ImageCaptchaParams_2 {
    /** 图片验证码 id */
    imageId: string;
    /** 图片验证码 */
    imageCaptcha: string;
}

declare interface ImageCutOptions {
    x: number;
    y: number;
    width: number;
    height: number;
    url: string;
}

/**
 * 图片验证码信息
 */
export declare interface ImageVerifyCodeData {
    /** 验证码 id */
    imageId: string;
    /** 验证码图片地址 */
    url: string;
    /** 图片验证码的长度 */
    length: number;
}

/**
 * 图片验证码信息
 */
declare interface ImageVerifyCodeData_2 {
    /** 验证码 id */
    imageId: string;
    /** 验证码图片地址 */
    url: string;
    /** 图片验证码的长度 */
    length: number;
}

/**
 * 插入本地打赏消息选项
 */
export declare type InsertLocalRewardChatMsgOptions = {
    /** 打赏类型 */
    donateType: DonateType.Good;
    /** 道具图片 */
    goodImage: string;
    /** 道具动效 */
    dynamicFile?: string;
    /** 道具名称 */
    goodName: string;
    /** 道具数量 */
    goodCount?: number;
    /** 是否免费打赏 */
    isFree: boolean;
} | {
    /** 打赏类型 */
    donateType: DonateType.Cash;
    /** 打赏金额 */
    amount?: string | number;
};

declare class InteractionBase {
    /**
     * @deprecated 兼容旧版具备 __iarCore 属性，后续将移除
     */
    public __iarCore: InteractionCore;

    /**
     * @deprecated 兼容旧版具备 iarCore 属性，后续将移除
     */
    public iarCore: InteractionCore;

    constructor(public interactionCore: InteractionCore) {
        this.__iarCore = interactionCore;
        this.iarCore = interactionCore;
    }
}

declare class InteractionBase_2 {
    /**
     * @deprecated 兼容旧版具备 __iarCore 属性，后续将移除
     */
    public __iarCore: InteractionCore;

    /**
     * @deprecated 兼容旧版具备 iarCore 属性，后续将移除
     */
    public iarCore: InteractionCore;

    constructor(public interactionCore: InteractionCore) {
        this.__iarCore = interactionCore;
        this.iarCore = interactionCore;
    }
}

declare class InteractionBase_3 {
    /**
     * @deprecated 兼容旧版具备 __iarCore 属性，后续将移除
     */
    public __iarCore: InteractionCore;

    /**
     * @deprecated 兼容旧版具备 iarCore 属性，后续将移除
     */
    public iarCore: InteractionCore;

    constructor(public interactionCore: InteractionCore) {
        this.__iarCore = interactionCore;
        this.iarCore = interactionCore;
    }
}

declare class InteractionBase_4 {
    /**
     * @deprecated 兼容旧版具备 __iarCore 属性，后续将移除
     */
    public __iarCore: InteractionCore;

    /**
     * @deprecated 兼容旧版具备 iarCore 属性，后续将移除
     */
    public iarCore: InteractionCore;

    constructor(public interactionCore: InteractionCore) {
        this.__iarCore = interactionCore;
        this.iarCore = interactionCore;
    }
}

declare class InteractionBase_5 {
    /**
     * @deprecated 兼容旧版具备 __iarCore 属性，后续将移除
     */
    public __iarCore: InteractionCore;

    /**
     * @deprecated 兼容旧版具备 iarCore 属性，后续将移除
     */
    public iarCore: InteractionCore;

    constructor(public interactionCore: InteractionCore) {
        this.__iarCore = interactionCore;
        this.iarCore = interactionCore;
    }
}

declare class InteractionBase_6 {
    /**
     * @deprecated 兼容旧版具备 __iarCore 属性，后续将移除
     */
    public __iarCore: InteractionCore;

    /**
     * @deprecated 兼容旧版具备 iarCore 属性，后续将移除
     */
    public iarCore: InteractionCore;

    constructor(public interactionCore: InteractionCore) {
        this.__iarCore = interactionCore;
        this.iarCore = interactionCore;
    }
}

/**
 * 互动核心实例
 */
declare class InteractionCore {
    config: InteractionCoreConfig;
    RequestAuthorizeMethod: typeof RequestAuthorizeMethod;
    SecurityMode: typeof SecurityMode;
    CheckSensitiveWordsFailReason: typeof CheckSensitiveWordsFailReason;
    polyvApi: PolyvApiRequest;
    chatApi: ChatApiRequest;
    staticApi: StaticRequest;
    otherApi: PolyvRequest;
    logger: Logger;
    private __rtas;
    /**
     * 伪造 Socket
     * @description 允许外部伪造 socket 事件中心从而实现互动流程，比如互动重放
     */
    private __fakeSocket;
    getFakeSocket(): EventEmitter<any, string>;
    /** 缓存 socket 事件列表 */
    private __socketCacheMap;
    /** 已清空缓存的应用名称集合，这些应用不再进行缓存 */
    private __clearedCacheApps;
    private __setSocketCache;
    getSocketCache<D = any>(appName: string): SocketCacheData<D>[];
    /**
     * 清除指定 App 的 socket 缓存
     * @param appName 应用名称
     */
    clearSocketCache(appName: string): void;
    constructor(config: InteractionCoreConfig);
    /**
     * 设置核心
     */
    setup(): void;
    /**
     * 获取 socket 实例
     */
    getSocket(): Promise<MaybeSocket | undefined>;
    /**
     * 通过 socket 实例获取聊天令牌
     */
    getChatToken(): Promise<string | undefined>;
    /**
     * 发送 socket 数据
     * @ignore
     * @param socketData socket 数据
     * @param socketType socket 类型，默认：message
     */
    emitSocket<D = unknown>(socketData: unknown, socketType?: SocketEventType, options?: {
        /** 是否检查 code 返回，默认：true */
        checkCode?: boolean;
    }): Promise<D>;
    private __socketListens;
    /**
     * 监听 socket 消息
     */
    private __listenSocketEvent;
    private __appSocketEventStore;
    private __createSocketHandle;
    /**
     * 添加 socket 事件监听
     * @param appName 应用名称
     * @param handlers 消息事件处理对象
     * @param socketType socket 事件类型，默认：message
     */
    addSocketHandles(appName: string, handlers: SocketEventStoreHandlers, socketType?: SocketEventType): void;
    /**
     * 获取来源信息
     */
    getSourceInfo(check?: true): Promise<Required<SourceInfo>>;
    getSourceInfo(check: false): Promise<Required<SourceInfo> | undefined>;
    /**
     * 获取频道信息
     */
    getChannelInfo(): Promise<ChannelInfo>;
    /**
     * 获取额外的业务信息
     */
    getExtBusinessInfo(): Promise<ExtBusinessInfo_2>;
    /**
     * 获取频道配置
     */
    getChannelConfig(): Promise<ChannelConfig_2 | undefined>;
    getUserInfo(): Promise<UserInfo_2>;
    /**
     * 判断是否为特殊用户
     * @returns 是否为特殊用户
     */
    isSpecialUser(): Promise<boolean>;
    /**
     * 获取域名
     */
    getDomainInfo(): Required<DomainInfo_2>;
    /**
     * 生成用于重定向的二维码地址
     * @param url 二维码内容
     */
    generateQrcodeUrl(url: string): string;
    /**
     * 延迟存储器
     */
    private __delayStore;
    /**
     * 等待互动的主动延迟
     * @param delayKey 延迟 key
     * @param defaultDelayTime 默认延迟时间，默认为 0
     * @returns Promise 返回主动延迟的时间
     */
    waitInitiativeDelay(delayKey: string, defaultDelayTime?: number): Promise<number>;
    /**
     * 终止互动的主动延迟
     * @param delayKey 延迟 key
     */
    stopInitiativeDelay(delayKey: string): void;
    /**
     * 记录请求中的 promise，避免多个应用同时请求
     */
    private __pendantPromise;
    /**
     * 获取挂件列表
     */
    getInternalPendantList(type: InternalPendantType): Promise<InternalPendantData[]>;
    trackEvent(data: TrackEventData): Promise<void>;
    private __imageCutTokens;
    /**
     * 上传图片
     * @param options 上传图片选项
     */
    uploadImage(options: UploadImageOptions): Promise<{
        url: string;
    }>;
    /**
     * 裁剪图片
     * @param options 裁剪选项
     */
    cropperImage(options: ImageCutOptions): Promise<{
        url: string;
    }>;
    checkSensitiveWords(content: string): Promise<CommonResult_2<CheckSensitiveWordsFailReason, {
        sensitive: boolean;
        words: string[];
    }>>;
}

declare interface InteractionCoreConfig {
    /**
     * 聊天室 socket.io 实例
     */
    getSocket?: MaybePromise_2<MaybeSocket | undefined>;
    /**
     * 获取频道信息
     */
    getChannelInfo?: MaybePromise_2<ChannelInfo>;
    /**
     * 获取其他业务信息
     */
    getExtBusinessInfo?: MaybePromise_2<ExtBusinessInfo_2>;
    /**
     * 获取频道配置
     */
    getChannelConfig?: MaybePromise_2<ChannelConfig_2>;
    /**
     * 获取来源信息
     */
    getSourceInfo?: MaybePromise_2<SourceInfo>;
    /**
     * 获取用户信息
     */
    getUserInfo: MaybePromise_2<UserInfo_2>;
    /**
     * 获取用户令牌信息
     */
    getViewerToken?: MaybePromise_2<ViewerTokenData>;
    /**
     * 获取频道令牌信息
     */
    getChannelToken?: MaybePromise_2<ChannelTokenData>;
    /**
     * 获取互动主动延迟时间，单位：毫秒
     */
    getInitiativeDelayTime?: MaybePromise_2<number>;
    /**
     * 域名信息
     */
    domainInfo?: DomainInfo_2;
    /**
     * 埋点配置
     */
    getRtasConfig?: MaybePromise_2<RtasConfig>;
    /**
     * 授权方式
     * @default RequestAuthorizeMethod.Token
     */
    authorizeMethod?: RequestAuthorizeMethod;
    /**
     * 获取 app 签名
     */
    getAppSign?: GetAppSignFn;
    /**
     * 应用签名密钥
     */
    appSignSecretKey?: AppSignSecretKey;
    /**
     * 是否使用放重放，仅 `RequestAuthorizeMethod.Sign` 时有效
     * @default false
     */
    signatureNonce?: boolean;
    /**
     * 签名方式，仅 `RequestAuthorizeMethod.Sign` 时有效
     * @default SignatureMethod.MD5
     */
    signatureMethod?: SignatureMethod;
    /**
     * 安全模式
     */
    securityMode?: SecurityMode;
    /**
     * SM2 密钥，仅 `SecurityMode.SM2` 时有效
     */
    sm2Key?: SM2Key;
}

/** 微活动设置 */
export declare interface InteractionMicroActivity {
    /** 是否启用微活动 */
    microActivityEnabled: YN;
    /** 微活动挂件图标 */
    pendantIcon: string;
}

export { InteractionReceiveConfig }

/**
 * 互动红包雨皮肤设置
 */
export declare interface InteractionRedpackRainSkin {
    /** 是否开启自定义设置 */
    customEnabled: YN;
    /** 红包雨下落图图片 */
    images: string[];
    /** 红包雨底部背景图 */
    backgroundImage: string;
}

/**
 * 互动红包皮肤设置
 */
export declare interface InteractionRedpackSkin {
    /** 红包封面图 */
    redpackImage: string | null;
}

/**
 * 频道互动功能设置
 */
export declare interface InteractionSetting {
    /** 红包皮肤设置 */
    redpackSkin: InteractionRedpackSkin | null;
    /** 红包雨皮肤设置 */
    redpackRainSkin: InteractionRedpackRainSkin;
    /** 微活动设置 */
    microActivity: InteractionMicroActivity;
    /** 频道邀请有礼活动 */
    channelInviteActivity?: ChannelInvitePrizeActivity;
    /** 任务奖励活动设置 */
    taskRewardActivity: InteractionTaskRewardActivity;
    /** 投票设置 */
    voteSetting: InteractionVoteSetting | null;
}

/**
 * 任务奖励活动设置
 */
export declare interface InteractionTaskRewardActivity {
    /** 当前进行中的任务奖励活动ID */
    onGoingActivityId: number | null;
}

/**
 * 投票设置
 */
export declare interface InteractionVoteSetting {
    /** 投票活动ID */
    id: number;
    /** 投票标题 */
    voteTitle: string;
    /** 结果展示类型 */
    resultShowType: number;
    /** 最大投票数 */
    maxVote: number;
    /** 投票规则 */
    voteRule: string;
    /** 布局类型 1-单列 2-双列 */
    layoutType: number;
}

/**
 * 互动接收端模块事件
 * @eventenum {@link InteractReceiveEventsRelations}
 */
export declare enum InteractReceiveEvents {
    /**
     * 互动在授权后 setup 完成
     * @version v2.7.0
     * @internal
     * @ignore
     */
    InteractSetupedAfterAuth = "InteractSetupedAfterAuth",
    /**
     * 商品库点击事件
     * @description 观众点击商品后触发该事件。
     * @example
     * ```js
     * watchCore.interactReceive.eventEmitter.on(InteractReceiveEvents.ProductClick, (data) => {
     *   toast.info(`${data.nickname}点击了${data.name}`);
     * });
     * ```
     */
    ProductClick = "ProductClick",
    /**
     * 商品下单数量事件
     * @version v2.0.0
     * @example
     * ```js
     * watchCore.interactReceive.eventEmitter.on(InteractReceiveEvents.ProductBuyTimes, (data) => {
     *   console.log('3 秒内频道商品下单列表', data.list);
     * });
     * ```
     */
    ProductBuyTimes = "ProductBuyTimes",
    /**
     * 互动设置信息更新事件
     * @version v0.12.0
     * @example
     * ```js
     * watchCore.interactReceive.eventEmitter.on(InteractReceiveEvents.InteractSettingUpdate, () => {
     *   const interactSetting = watchCore.interactReceive.getInteractSetting()
     *   console.log('互动设置', interactSetting);
     * });
     * ```
     */
    InteractSettingUpdate = "InteractSettingUpdate",
    /**
     * 签到次数事件
     * @version v2.0.0
     * @example
     * ```js
     * watchCore.interactReceive.eventEmitter.on(InteractReceiveEvents.SignInTimes, (data) => {
     *   console.log('3 秒内频道签到次数', data.time);
     *   console.log('3 秒内频道首个签到昵称', data.nickname);
     * });
     * ```
     */
    SignInTimes = "SignInTimes"
}

/**
 * 互动接收端模块事件回调参数配置
 */
export declare type InteractReceiveEventsRelations = {
    [InteractReceiveEvents.ProductClick]: {
        /**
         * 用户昵称
         */
        nickname: string;
        /**
         * 商品 id
         */
        productId: string;
        /**
         * 商品名称
         */
        name: string;
        /**
         * 商品类型
         */
        type: ProductClickType;
    };
    [InteractReceiveEvents.ProductBuyTimes]: {
        /**
         * 首个下单观众昵称
         */
        nickname: string;
        /**
         * 次数
         */
        count: number;
        /**
         * 商品 id
         */
        productId: string;
        /**
         * 商品名称
         */
        productName: string;
        /**
         * 商品类型
         */
        productType: IarProductType;
    };
    [InteractReceiveEvents.SignInTimes]: {
        /**
         * 首个下单观众昵称
         */
        nickname: string;
        /**
         * 次数
         */
        count: number;
    };
};

/**
 * 互动功能设置信息
 */
export declare interface InteractSetting {
    /** 招聘直播开关 */
    recruitmentEnabled: boolean;
    /** 商品库开关 */
    productEnabled: boolean;
    /** 商品库超管总开关 */
    liveProductEnabled: boolean;
    /** 商品库数据上报开关 */
    productTrackEnabled: boolean;
    /** 商品库链接跳转提示开关 */
    productLinkJumpTipEnabled: boolean;
    /** 商品直接跳转外链开关 */
    outLinkProductRedirectEnabled: boolean;
    /** 商品入口位置 */
    productEntryPosition: ProductEntryPosition;
    /** 报名抽奖开关 */
    enrollLotteryEnabled: boolean;
    /** 抽奖手动结束开关 */
    lotteryManualEndEnabled: boolean;
    /** 条件抽奖开关 */
    conditionLotteryEnabled: boolean;
    /** 条件抽奖是否自动弹窗开关 */
    conditionLotteryAutoPopperEnabled: boolean;
    /**
     * 抽奖版本
     * @deprecated 从 v2.8.0 开始废弃
     */
    lotteryVersion: 'v1' | 'v2';
    /** 投诉反馈开关 */
    watchFeedbackEnabled: boolean;
    /** 投诉反馈按钮位置 */
    watchFeedbackButtonPositions: ('EXTERNAL' | 'CONTROL_STRIP_INNER' | string)[];
    /** 投票活动开关 */
    voteActiveEnabled: boolean;
    /** 互动红包开关 */
    redpackEnabled: boolean;
    /** 红包背景图 */
    redpackImage: string;
    /** 红包雨底部背景图 */
    redpackRainBottomImage: string;
    /** 红包雨下落物图片 */
    redpackRainImages: string[];
    /**
     * 云席功能开关
     * @version v0.10.0
     */
    seatTableEnabled: boolean;
    /**
     * 云席模板
     * @version v0.10.0
     */
    seatTableTemplate: SeatTableTemplate;
    /**
     * 嘉宾普通云席最大数量
     * @version v0.10.0
     */
    seatMaxNumber: number;
    /**
     * 嘉宾 vip 云席最大数量
     * @version v0.10.0
     */
    seatVipMaxNumber: number;
    /**
     * 云席自定义文案开关
     * @version v0.10.0
     */
    seatCustomTextEnabled: boolean;
    /**
     * 云席自定义文案
     * @version v0.10.0
     */
    seatCustomText: string;
    /**
     * 云席嘉宾证开关
     * @version v0.10.0
     */
    seatGuestCardEnabled: boolean;
    /**
     * 抽奖按钮中文文案
     * @version v1.1.0
     */
    lotteryGiftButtonTextCH: string;
    /**
     * 抽奖按钮英文文案
     * @version v1.1.0
     */
    lotteryGiftButtonTextEN: string;
    /**
     * 是否显示热卖特效
     * @version v1.3.0
     */
    productHotEffectEnabled: boolean;
    /**
     * 热卖词数据
     * @version v1.3.0
     */
    productHotEffectTips?: ProductHotEffectTips;
    /**
     * 优惠券开关
     * @version v2.1.0
     */
    couponEnabled: boolean;
    /**
     * 我的奖励开关
     * @version v2.9.0
     */
    personalRewardEnabled: boolean;
}

declare type InterceptRequestUrl<Options extends ApiOptions = ApiOptions> = (currentRequestUrl: string, apiUrl: string, options: Options) => {
    requestUrl?: string;
    options?: Options;
};

declare type InterceptRequestUrl_2<Options extends ApiOptions_2 = ApiOptions_2> = (currentRequestUrl: string, apiUrl: string, options: Options) => {
    requestUrl?: string;
    options?: Options;
};

declare interface InternalPendantData {
    /** 目标 id */
    pandantId: string;
    /** 挂件类型 */
    type: InternalPendantType;
}

declare type InternalPendantType = 'condition_lottery' | 'subject_pk';

/**
 * 邀请有礼活动信息
 */
export declare interface InviteActivityInfo {
    /** 邀请有礼活动id */
    id: string | null;
    /** 邀请有礼开关，默认关 */
    enabled: boolean;
    /** 邀请有礼活动介绍 */
    introduction: string;
    /** 邀请有礼活动截止时间，时间戳(毫秒) */
    endTime: number | null;
    /** 邀请有礼活动状态 */
    status: InviteActivityStatus;
}

/** 邀请有礼活动状态 */
export declare enum InviteActivityStatus {
    /** 不存在 */
    NoExist = -1,
    /** 已结束 */
    End = 0,
    /** 进行中 */
    Processing = 1
}

export declare interface InviteBaseItem {
    /** 用户头像 */
    avatar: string;
    /** 用户昵称 */
    nickname: string;
}

/**
 * 邀请好友抽奖条件
 */
declare interface InviteCondition extends LotteryConditionBase<LotteryCondition.Invite> {
    /**
     * 邀请类型
     */
    inviteType: LotteryInviteType;
    /**
     * 邀请人数
     */
    inviteCount: number;
    /**
     * 已邀请人数
     */
    invitedCount: number;
    /**
     * 还需邀请人数
     */
    needCount: number;
    /**
     * 观看页地址
     */
    watchUrl: string;
    /**
     * 观看页地址二维码
     */
    watchQrCode: string;
    /**
     * 邀请地址
     */
    inviteUrl: string;
    /**
     * 邀请地址二维码
     */
    inviteQrCode: string;
}

declare interface InviteCountDownData {
    remain: number;
    total: number;
}

/**
 * 一客一码信息采集表单节点
 */
export declare interface InviteCustomerCollectFieldItem {
    /**
     * 采集类型
     */
    type: InviteCustomerCollectType;
    /**
     * 是否必填
     */
    required: boolean;
}

/**
 * 一客一码信息采集设置
 */
export declare interface InviteCustomerCollectSetting {
    /**
     * 字段列表
     */
    fieldList: InviteCustomerCollectFieldItem[];
}

/**
 * 一客一码信息收集类型
 */
export declare enum InviteCustomerCollectType {
    /**
     * 联系人名称
     */
    UserName = "username",
    /**
     * 地址
     */
    Address = "address",
    /**
     * 企业名称
     */
    CorpName = "corpName",
    /**
     * 职务
     */
    Position = "position",
    /**
     * 邮箱
     */
    Email = "email"
}

export declare enum InviteDetailExportErrorReason {
    /** 超过下载人数并发限制 */
    OverLimit = "OverLimit",
    /** 重复请求 */
    Duplicate = "Duplicate",
    /** 其他 */
    Others = "Others"
}

/**
 * 邀请明细数据
 */
export declare interface InviteDetailListItem extends InviteBaseItem {
    /** 受邀者ID */
    viewerId: string;
    createdTime: number;
    ext: string | null;
    openId: string;
    receiverId: number;
    senderId: string;
}

/**
 * 邀请明细的错误原因
 */
export declare enum InviteDetailListRequestFailReason {
    /** 功能关闭 */
    FeatureClose = "FeatureClose",
    /** 未知错误 */
    Unknown = "Unknown"
}

/**
 * 邀请明细下载状态
 */
export declare enum InviteDetailLoadStatus {
    /** 未初始化 */
    UnInit = "UnInit",
    /** 下载中 */
    Loading = "Loading",
    /** 下载完成 */
    Complete = "Complete",
    /** 下载错误 */
    Error = "Error"
}

/** 邀请明细回调数据 */
export declare interface InviteDetailLoadStatusData {
    /** 下载状态类型 */
    type: InviteDetailLoadStatus;
    /** 下载信息, 如下载链接 */
    content?: string;
    /** 下载状态对应详细信息 */
    reason?: InviteDetailExportErrorReason;
}

/** 邀请明细接口返回内容 */
export declare interface InviteDetailLoadStatusResponseData {
    /** 下载链接 */
    downloadUrl: string;
    /** 下载状态  */
    status: InviteExportResponseStatus;
}

/**
 * 邀请模块事件
 * @eventenum {@link InviteEventsRelations}
 */
export declare enum InviteEvents {
    /**
     * 邀请有礼活动信息修改
     *
     * 邀请模块会保存邀请有礼活动信息，通过该事件监听邀请状态改变
     * @version v0.12.0
     * @example
     * ```js
     * watchCore.invite.eventEmitter.on(InviteEvents.InviteActivityInfoChange, (evt) => {
     *   const inviteActivityInfo = evt.inviteActivityInfo;
     *   console.log('邀请有礼活动是否可用', inviteActivityInfo.enabled);
     * });
     * ```
     */
    InviteActivityInfoChange = "InviteActivityInfoChange",
    /**
     * 邀请明细下载状态变更
     * @version v1.5.0
     */
    InviteDetailLoadStatusChange = "InviteDetailLoadStatusChange"
}

/**
 * 邀请模块事件回调参数配置
 */
export declare type InviteEventsRelations = {
    [InviteEvents.InviteActivityInfoChange]: {
        /**
         * 邀请有礼活动信息
         */
        inviteActivityInfo: InviteActivityInfo;
    };
    /**
     * 邀请明细下载状态信息
     */
    [InviteEvents.InviteDetailLoadStatusChange]: InviteDetailLoadStatusData;
};

export declare enum InviteExportResponseStatus {
    /** 等待处理 */
    WAITING = "WAITING",
    /** 处理中 */
    HANDLING = "HANDLING",
    /** 处理成功 */
    SUCCESS = "SUCCESS",
    /** 处理失败 */
    FAIL = "FAIL",
    /** 取消处理 */
    CANCELED = "CANCELED",
    /** 等待回调 */
    WAIT_CALLBACK = "WAIT_CALLBCK"
}

export declare interface InviteListSetting {
    /**
     * 邀请榜仅显示人数
     */
    inviteListPartialDisplayNumber: number;
    /**
     * 邀请榜是否展示全部观众
     */
    inviteListDisplayType: 'full' | 'partial' | '';
    /**
     * 邀约明细下载开关，默认关
     */
    inviteDetailExportEnabled?: YN;
}

export declare interface InvitePosterData {
    /** 观看地址参数 */
    watchParams: string;
    /** 是否隐藏品牌 */
    brandHideEnabled: YN;
    /** 信息 */
    promotion: InvitePosterDataPromotion;
    /** 第三方邀请海报二维码 */
    thirdInviteQrcodeUrl: string | null;
    /** 是否使用第三方邀请海报二维码 */
    useThirdInviteQrcode: boolean;
}

export declare interface InvitePosterDataPromotion {
    /** 头像开关 */
    invitePosterAvatarEnabled: number;
    /** 头像 x 位置 */
    avatarPositionX: number;
    /** 头像 y 位置 */
    avatarPositionY: number;
    /** 头像大小 */
    avatarSize: number;
    /** 自定义用户类型 */
    customUserType: string;
    /** 邀请封面图 */
    inviteCoverImage: string;
    /** 海报图片链接(底图) */
    invitePosterImageUrl: string;
    /** 昵称开关 */
    invitePosterNickNameEnabled: YN;
    /** 昵称 x 位置 */
    nickNamePositionX: number;
    /** 昵称 y 位置 */
    nickNamePositionY: number;
    /** 昵称字号 */
    nickNameSize: number;
    /** 昵称颜色 */
    nickNameColor: string;
    /** 二维码x位置 */
    qrCodePositionX: number;
    /** 二维码y位置 */
    qrCodePositionY: number;
    /** 二维码大小 */
    qrCodeSize: number;
    /** 观看地址 */
    watchUrl: string;
}

/** 邀请有礼奖励项 */
export declare type InvitePrizeItem = InvitePrizeReceiveForm | InvitePrizeReceiveLink | InvitePrizeReceiveQrCode;

/**
 * 邀请有礼中奖领取收集信息
 */
export declare type InvitePrizeReceiveCollectInfo = Required<InvitePrizeReceiveFormFieldItemOrigin>;

/** 邀请有礼奖励项-公共 */
declare interface InvitePrizeReceiveCommon extends InvitePrizeReceiveCommonOrigin {
    /** sdk 内部处理新增字段 */
    /** 领奖范围最小值 */
    receiveAreaMin: number;
    /** 领奖范围最大值 */
    receiveAreaMax: number;
}

/** 邀请有礼奖励项-公共（源数据） */
declare interface InvitePrizeReceiveCommonOrigin {
    /** 奖品Id */
    id: string;
    /** 中奖人数 */
    headCount: number;
    /** 奖品名称 */
    name: string;
    /** 奖品图片 */
    pictureUrl: string | null;
}

/** 邀请有礼奖励项-表单领取 */
export declare interface InvitePrizeReceiveForm extends InvitePrizeReceiveCommon {
    /** 奖品领取类型 */
    receiveType: InvitePrizeReceiveType.Form;
    /** 奖品领取信息 */
    receiveInfo: {
        formInfo: InvitePrizeReceiveFormFieldItem[];
    };
}

/**
 * 邀请有礼中奖领取收集参数
 */
export declare type InvitePrizeReceiveFormCollectParams = {
    /** 中奖记录id */
    id: string;
    /** 表单数据 */
    formData: Array<Required<InvitePrizeReceiveFormFieldItem>>;
};

/** 邀请有礼中奖表单项 */
export declare interface InvitePrizeReceiveFormFieldItem extends InvitePrizeReceiveFormFieldItemOrigin {
    /** SDK 内部处理生成, type 拼接当前索引  */
    fieldId: string;
}

export declare interface InvitePrizeReceiveFormFieldItemOrigin {
    /** 字段类型 */
    type: InvitePrizeReceiveFormFieldType;
    /** 字段描述 */
    field: string;
    /** 提示语 */
    tips: string;
    /** 是否必填 */
    required: boolean;
    /** 表单值 */
    value?: string;
}

export declare enum InvitePrizeReceiveFormFieldType {
    /** 姓名 */
    Name = "userName",
    /** 手机号 */
    Phone = "userPhone",
    /** 自定义 */
    Custom = "custom"
}

/** 邀请有礼奖励项-外链领取 */
export declare interface InvitePrizeReceiveLink extends InvitePrizeReceiveCommon {
    /** 奖品领取类型 */
    receiveType: InvitePrizeReceiveType.Link;
    /** 奖品领取信息 */
    receiveInfo: {
        prizeUrl: string;
    };
}

/** 邀请有礼奖励项-二维码领取 */
export declare interface InvitePrizeReceiveQrCode extends InvitePrizeReceiveCommon {
    /** 奖品领取类型 */
    receiveType: InvitePrizeReceiveType.QrCode;
    /** 奖品领取信息 */
    receiveInfo: {
        /** 二维码 */
        qrCode: string;
        /** 二维码提示语 */
        qrCodeTips: string;
    };
}

/** 邀请有礼奖品领取类型 */
export declare enum InvitePrizeReceiveType {
    /** 表单领取 */
    Form = "form",
    /** 外链领取 */
    Link = "link",
    /** 二维码领取 */
    QrCode = "qrCode"
}

/**
 * 邀请有礼中奖者基础信息
 */
declare interface InvitePrizeWinnerBaseInfo extends InvitePrizeWinnerBaseInfoOrigin {
    /** 自己是否中奖 */
    isSelf: boolean;
    /** 是否已领奖 */
    hasReceived: boolean;
    /** 奖品图片 */
    prizeImage: string | null;
}

/**
 * 邀请有礼中奖者基础信息（源数据）
 */
export declare interface InvitePrizeWinnerBaseInfoOrigin {
    /** 中奖记录 id */
    id: string;
    /** 奖品 Id */
    prizeId: string | null;
    /** 奖品名称 */
    prizeName: string | null;
    /** 获奖者名称 */
    viewerName: string | null;
    /** 获奖者Id */
    viewerId: string;
}

/** 邀请有礼中奖者信息-表单领取 */
export declare interface InvitePrizeWinnerForm extends InvitePrizeWinnerBaseInfo {
    /** 奖品领取类型 */
    receiveType: InvitePrizeReceiveType.Form;
    /** 奖品领取信息 */
    receiveInfo: {
        formInfo: InvitePrizeReceiveFormFieldItem[];
    };
}

/**
 * 邀请有礼中奖者信息
 */
export declare type InvitePrizeWinnerInfo = InvitePrizeWinnerForm | InvitePrizeWinnerLink | InvitePrizeWinnerQrCode;

/** 邀请有礼中奖者信息-外链领取 */
export declare interface InvitePrizeWinnerLink extends InvitePrizeWinnerBaseInfo {
    /** 奖品领取类型 */
    receiveType: InvitePrizeReceiveType.Link;
    /** 奖品领取信息 */
    receiveInfo: {
        prizeUrl: string;
    };
}

/** 邀请有礼中奖者信息-二维码领取 */
export declare interface InvitePrizeWinnerQrCode extends InvitePrizeWinnerBaseInfo {
    /** 奖品领取类型 */
    receiveType: InvitePrizeReceiveType.QrCode;
    /** 奖品领取信息 */
    receiveInfo: {
        /** 二维码 */
        qrCode: string;
        /** 二维码提示语 */
        qrCodeTips: string;
    };
}

/**
 * 当前用户的排行榜信息
 */
export declare interface InviteRankCurrentViewer extends InviteRankItem {
    /** 用户排行 */
    rank: number;
}

/**
 * 邀请榜节点
 */
export declare interface InviteRankItem extends InviteBaseItem {
    /** 用户头像 */
    avatar: string;
    /** 用户邀请人数 */
    inviteNum: number;
    /** 用户昵称 */
    nickname: string;
    /**
     * 用户微信 openId
     * @desc 开启用户体系后，不一定是微信 openId，可能是其他平台的 id
     */
    openId: string;
    /** 是否为当前观众 */
    me: boolean;
}

/**
 * 邀请榜请求的错误原因
 */
export declare enum InviteRankRequestFailReason {
    /** 功能关闭 */
    FeatureClose = "FeatureClose",
    /** 未知错误 */
    Unknown = "Unknown"
}

/**
 * 邀请观看-审核状态
 */
export declare enum InviteWatchAuditStatus {
    /** 未申请 */
    NotExist = -1,
    /** 审核中/待审核 */
    Auditing = 0,
    /** 审核通过 */
    Pass = 1
}

/**
 * 邀请观看授权信息
 */
export declare interface InviteWatchAuthInfo {
    /** 审核状态 */
    status: InviteWatchAuditStatus;
    /** 邀请人/分销员信息 */
    saleInfo?: {
        /** 昵称 */
        nickname: string;
        /** 头像 */
        avatar: string;
    };
}

export declare type joinAsAudienceResult = CommonResult<string>;

declare interface JoinSocketDataCallbackParams {
    socketData: WhiteBoardSdkTypes.SocketType;
    delayTime?: number;
}

/**
 * 语言类型枚举
 */
declare enum LangType {
    /** 简体中文 */
    ZH_CN = "zh_CN",
    /** 繁体中文 */
    ZH_TW = "zh_TW",
    /** 英语 */
    English = "en",
    /** 日语 */
    Japanese = "ja",
    /** 韩语 */
    Korean = "ko",
    /** 俄语 */
    Russian = "ru"
}

/**
 * 语言类型枚举
 */
declare enum LangType_2 {
    /** 简体中文 */
    ZH_CN = "zh_CN",
    /** 繁体中文 */
    ZH_TW = "zh_TW",
    /** 英语 */
    English = "en",
    /** 日语 */
    Japanese = "ja",
    /** 韩语 */
    Korean = "ko",
    /** 俄语 */
    Russian = "ru"
}

/** 语言类型 */
export declare type LanguageType = WatchSdkLangEnum | OriginLanguageType;

/**
 * 将大写英文字母转换为数字
 * @param letters 字母
 * @returns 数字
 */
declare function lettersToNumber(letters: string): number;

export declare enum LikeEffectType {
    /** 系统 */
    System = "SYSTEM",
    /** 节日 */
    Festival = "FESTIVAL",
    /** 自定义 */
    Custom = "CUSTOM"
}

/**
 * 直播预约配置
 */
export declare interface LiveBookingConfig {
    /** 是否开启了短信预约 */
    smsBookingEnabled: boolean;
    /** 是否已短信预约 */
    isSmsLiveBooking: boolean;
    /** 是否开启了微信预约 */
    wxBookingEnabled: boolean;
    /** 是否已微信预约 */
    isWxLiveBooking: boolean;
    /** 是否已关注了微信公众号 */
    isWxSubscribed: boolean;
    /** 微信预约弹层提示文案 */
    wxBookingTips: string;
    /** 是否展示微信预约人数 */
    wxBookingCountVisible: boolean;
    /** 微信预约人数 */
    wxBookingCount: number;
    /** 微信公众号图片 */
    wxMpImageUrl: string;
    /** 是否开启了自定义预约 */
    customBookingEnabled: boolean;
    /** 是否已自定义预约 */
    isCustomLiveBooking: boolean;
}

/**
 * 直播预约失败原因
 */
export declare enum LiveBookingFailReason {
    /** 位置错误 */
    Unknown = "Unknown",
    /** 短信验证码错误 */
    VerifyCodeError = "VerifyCodeError"
}

/**
 * 直播预约结果
 */
export declare type LiveBookingResult = CommonResult<LiveBookingFailReason, LiveBookingWxSuccess>;

export declare interface LiveBookingWxSuccess {
    wxOfficialAccountQRCodeUrl?: string | undefined;
}

declare type LiveLowLatencyClientFn = typeof LiveLowLatencyPlayerModule.Client;

declare interface LiveMobilePlayerExtraFunc {
    j2s_addBarrageMessage?: (options: DanmuAddOptions) => void;
    /** 清除播放器时间轴标记点位 */
    clearPoint(): void;
    /** 添加播放器时间轴标记点位 */
    addPoint(secondList: number[]): void;
    /** 更新字幕按钮是否展示 */
    updateRTSubtitleDisplay(state: boolean): void;
    /** 更新字幕按钮是否打开 */
    updateRTSubtitleChecked(state: boolean): void;
    /** 显示回放字幕check */
    showPlaybackSubtitle(): void;
    /** 隐藏回放字幕check */
    hidePlaybackSubtitle(): void;
    /** 增加回放字幕选项开关 */
    addPlaybackSubtitle(param: AddPlaybackSubtitleOptionsType): void;
    /** 删除"回放字幕" 对应index的 checkbox */
    removePlaybackSubtitle(number: number): void;
    /** 更新字幕checkbox里选择btn显示状态 接口文档 https://wiki.igeeker.org/pages/viewpage.action?pageId=482190429 */
    updateCheckboxSelectState(index: number, isShow: boolean): void;
    /** 更新字幕checkbox里选择文案 */
    updateCheckboxSelectText(index: number, text: string): void;
}

declare interface LivePlayerAdBaseConfig {
    /** 自定义通用链接 */
    href?: string;
    /** 跳转类型 */
    hrefType?: AdvertHrefType;
    /** 自定义模式，为true时点击广告不跳转 */
    isCustom?: boolean;
    /** 广告持续时间 */
    duration?: number;
    /** 多平台移动端链接 */
    mobileLink?: string;
    /** 多平台PC端链接 */
    pcLink?: string;
    wxMiniprogramAppId?: string;
    wxMiniprogramOriginalId?: string;
    wxMiniprogramLink?: string;
}

declare interface LivePlayerAdConfig {
    /** 片头广告配置 */
    headAdConfig?: LivePlayerAdBaseConfig & {
        headIosLink?: string;
        headAndroidLink?: string;
        headHarmonyLink?: string;
    };
    /** 暂停广告配置 */
    stopAdConfig?: LivePlayerAdBaseConfig & {
        stopIosLink?: string;
        stopAndroidLink?: string;
        stopHarmonyLink?: string;
    };
}

/**
 * 直播播放器授权参数
 */
declare interface LivePlayerAuthOptions {
    /** 授权验证设置自定义的code */
    code?: string;
    /** 是否禁用播放器密码（PC） */
    banPassword?: boolean;
    /** 是否禁用播放器密码（mobile） */
    banpassword?: boolean;
}

/**
 * 直播播放器弹幕参数
 */
declare interface LivePlayerBarrageOptions {
    /** 弹幕功能开关，默认：false */
    danmuEnable?: boolean;
    /** 弹幕功能默认是否开启，默认：true */
    showDanmu?: boolean;
    /** 是否隐藏弹幕开关按钮，默认：false */
    banDanmuBtn?: boolean;
    /** 弹幕速度 */
    danmuSpeed?: number;
    /** 弹幕字号 */
    danmuSize?: number;
    /** 弹幕透明度 */
    danmuAlpha?: number;
    /** 弹幕显示方向 */
    danmuAreaDirection?: IDirection;
    /** 弹幕显示百分比 */
    danmuAreaPercentage?: number;
}

/**
 * 直播播放器基础参数
 */
declare interface LivePlayerBaseOptions {
    /** 创建的外层节点 */
    wrap: string | HTMLDivElement;
    /** 宽度 */
    width?: string | number;
    /** 高度 */
    height?: string | number;
    /** 移动端下是否使用 H5 同层播放，默认：false */
    useH5Page?: boolean;
    /** 自动播放，没设则读取 channelJson 中的值 */
    autoplay?: boolean;
    /** webview 下是否自动播放，默认：false */
    webviewAutoplay?: boolean;
    /** 是否禁用续播功能，默认：true */
    banHistoryTime?: boolean;
    /** 强制使用 H5 播放器，默认：false */
    forceHTML5?: boolean;
    /** 自定义 video 元素（mobile） */
    customVideoEle?: HTMLMediaElement;
    /** 显示音频按钮（mobile） */
    useAudioBtn?: boolean;
    /** 海外自动切换线路 */
    overseasAutoSwitchEnabled?: YN;
    /** 暖场视频是否支持暂停播放 */
    warmVideoFeatureEnabled?: boolean;
    /** 是否直接播放暖场视频（仅移动端） */
    directPlayWarmUp: boolean;
    /** 域名配置 */
    domainInfo?: LivePlayerDomainInfo;
    /**
     * 新场次开关
     * @desc 使用新场次开关后，直播回调需要判断是否为当前场次才正常回调
     */
    newSessionEnabled: boolean;
    /**
     * 新场次状态
     */
    newSessionStatus: LiveStatus;
    /**
     * 显示暂无直播，优先级比directPlayWarmUp 高
     */
    directPlayCutOff: boolean;
    /** 封面图片 */
    coverImg?: string;
    /** 封面跳转地址 */
    customCoverHref?: string;
}

declare interface LivePlayerChangeVodParams {
    /** 是否自动播放 */
    autoplay?: boolean;
    /** 播放时长 */
    duration?: number;
    /** 播放地址 */
    url?: string;
    /** 统计参数 */
    statistics?: {
        clipSessionId?: string;
        recordFileId?: string;
        sessionId?: string;
        videoId?: string;
    };
}

declare type LivePlayerCommonEvents = 's2j_onInitOver' | 's2j_onPlay' | 's2j_onPause' | 's2j_onStartPlay' | 's2j_onChannelJsonData' | 'onLineChanged' | 's2j_onLevelsChanged' | 's2j_volume' | 'apiStatus' | 's2j_onOver' | 'historyPlay' | 's2j_onPptDelayTime' | 's2j_marqueeName' | 'playing' | 'pause' | 'HEAD_AD_CLICKED' | 'STOP_AD_CLICKED' | 'statisticsInfo' | 's2j_onPlayerError';

/**
 * 直播播放器数据参数
 */
declare interface LivePlayerDataOptions extends PlayerLiveStatParams {
    /** 保利威账户 id */
    uid: string;
    /** 频道号 */
    vid: string | number;
    /** 流名 */
    name?: string;
    /** 后台设置单个视频暂存播放，则直播结束后播放暂存，默认：false */
    isAutoChange?: boolean;
    /** 是否强制使用接口的 sessionId，默认：false */
    forceSessionId?: boolean;
    /** 是否为内网播放，默认：0 */
    zone?: 0 | 1;
    /** 是否使用 rc 版本，默认：false */
    rc?: boolean;
    /** rc 版本号 */
    rcVersion?: string;
    /** 场次号 */
    sessionId?: string;
    /** 文件 id */
    recordFileId?: string;
    /** 裁减场次号 */
    clipSessionId?: string;
}

/**
 * @file 直播播放器参数类型
 */

/**
 * 直播播放器域名配置
 */
declare interface LivePlayerDomainInfo {
    /**
     * @default live.polyv.net
     */
    live?: string;
    /**
     * @default api.polyv.net
     */
    api?: string;
    /**
     * @default livejson.polyv.net
     */
    liveJson?: string;
    /**
     * @default player.polyv.net
     */
    player?: string;
    /**
     * @default rtas.videocc.net
     */
    rtas?: string;
    /**
     * @default rtas-2.videocc.net
     */
    rtasBackUp?: string;
}

declare type LivePlayerEvents = LivePlayerCommonEvents | LivePlayerPcEvents | LivePlayerMobileEvents;

/**
 * 直播播放器全屏参数
 */
declare interface LivePlayerFullScreenOptions {
    /** 是否使用网页全屏（mobile），默认：false */
    webPageFullScreen?: boolean;
    /** 网页全屏下的层叠数（mobile） */
    fullscreenZIndex?: number;
    /** 网页全屏方式（mobile），默认：none */
    fullScreenOrientation?: 'landscape' | 'portrait' | 'none';
    /** 是否使用Fullscreen API（mobile）（安卓增强全屏功能），默认：false, 仅安卓端生效， 开启后会使用fullscreen api 全屏，仅移动端生效 */
    useFullscreenApi?: boolean;
    /** 自定义全屏元素（mobile）， 开启 useFullscreenApi 后生效，仅移动端生效 */
    customFullscreenElement?: Element;
    /** 是否使用全屏锁定（mobile），默认：true。 在支持screen.orientation.lock的设备，设置true后全屏会锁屏幕方向，默认锁横屏，仅移动端生效 */
    useFullscreenLock?: boolean;
    /** 锁定方向，开启 useFullscreenLock 后生效, 仅移动端生效  */
    fullscreenLockOrientation?: 'landscape' | 'portrait';
}

/**
 * 直播播放器实例
 */
declare interface LivePlayerInstance extends Partial<LiveMobilePlayerExtraFunc> {
    /** 后台设置单个视频暂存播放，则直播结束后播放暂存 */
    isAutoChange: boolean;
    /** 播放 */
    j2s_resumeVideo(): void;
    /** 暂停 */
    j2s_pauseVideo(): void;
    /** 刷新流 */
    j2s_resetStream(): void;
    /** 设置音量（0～1） */
    j2s_setVolume(volume: number): void;
    /** 添加弹幕 */
    j2s_addBarrageMessage(options: DanmuAddOptions): void;
    /** 设置弹幕显示 */
    setBarrageStatus(status: boolean): void;
    /** 设置弹幕速度 */
    setBarrageSpeed(speed: number): void;
    /** 设置弹幕字号 */
    setBarrageSize(size: number): void;
    /** 设置弹幕显示方向 */
    setBarrageAreaDirection(direction: IDirection): void;
    /** 设置弹幕显示百分比 */
    setBarrageAreaPercentage(direction: number): void;
    /** 设置弹幕透明度 */
    setBarrageAlpha(alpha: number): void;
    /** 是否支持弹幕位置切换 */
    getBarrageLocationSupport(): boolean;
    /** 是否支持弹幕透明度切换 */
    getBarrageAlphaSupport(): boolean;
    /** 切换线路 */
    changeLine(line: number): void;
    /** 切换清晰度 */
    j2s_changeLevel(level: number): void;
    /** 设置倍速 */
    j2s_changeRate(rate: number): void;
    /** 获取当前播放时间 */
    j2s_getCurrentTime(): number;
    /** 设置播放进度 */
    j2s_seekVideo(time: number): void;
    /** 获取小窗状态 */
    getPictureInPictureStatus(): boolean;
    /** 进入小窗 */
    enterPictureInPicture(): Promise<PictureInPictureWindow>;
    /** 离开小窗 */
    leavePictureInPicture(): Promise<void>;
    /** 切换小窗 */
    togglePictureInPicture(): void;
    /**
     * 切换回放
     * @warn 会重置当前播放的视频倍速
     * */
    changeVod(params: LivePlayerChangeVodParams): void;
    /** 设置跑马灯内容 */
    j2s_changeHorseMessage(content: string): void;
    /** 冻结播放 */
    freezePlay(isFreeze: boolean): void;
    /** 多终端播放器 */
    multiPlayer?: LivePlayerInstance & LiveMobilePlayerExtraFunc;
    /** 是否支持直播时移 */
    getSupportTimeShift(): boolean;
    /** 获取直播模式 */
    getLiveMode(): 'timeShift' | string;
    /** 获取时移播放时间 */
    getTimeShiftCurrentTime(): number;
    /** 时移-获取总的播放时间 */
    getTotalDuration(): number;
    /** 时移到某个时间点 */
    timeShiftTo(opts: {
        start?: number;
    }): void;
    /** 修改参数 */
    changeParam?(param1?: unknown, param2?: unknown, param3?: unknown, param4?: unknown): void;
    /** 获取播放器统计信息 */
    getStatisticInfo(): PlayerStatisticsInfoCbParams;
    /** 获取播放器视频信息 */
    getVideoInfo(): PlayerVideoInfo;
    /** 刷新低延迟canvas的渲染，仅低延迟软解时有效 */
    resizeScreen(viewRotate?: number, bodyRotate?: number): void;
    /** 设置直播流token */
    setLiveStreamToken(token: string): void;
    /** 执行缓冲监测切换线路|清晰度 */
    switchDetectionByInfo(info: PlayerDetectionSwitchDetail): void;
    /** 退出网页全屏 */
    exitWebPageFullScreen(): void;
    /** 设置手势 seek 方向 */
    setGestureDirection(direction: GestureSeekDirection): void;
    /** 当前线路 */
    line: number;
    /** 当前清晰度 */
    df: number;
    /** 仅直播播放器移动端有， 类似df */
    multirate?: number;
    /** 获取当前音量，仅 PC 下存在 */
    vol?: number;
    video?: HTMLVideoElement;
    /** 监听事件 */
    on(event: LivePlayerEvents, fn: (...args: any[]) => void): void;
    off(event: LivePlayerEvents, fn: (...args: any[]) => void): void;
    event: {
        on(event: LivePlayerEvents, fn: (...args: any[]) => void): void;
        off(event: LivePlayerEvents, fn: (...args: any[]) => void): void;
    };
    /** 播放器版本号 */
    version: string;
    /** 销毁 */
    destroy(): void;
}

/**
 * 直播播放器语言参数
 */
declare interface LivePlayerLangOptions {
    /** 播放器多语言，0 或 'zh_CN' - 简体中文，1 或 'en' - 英语，'zh_TW' 繁体中文，'ja' - 日语，'ko' - 韩语。默认：0 */
    language?: 0 | 1 | string;
    /** 是否使用定制的英文翻译，默认：false */
    changeEnContent?: boolean;
    /** 多语言流 */
    streamLines?: 'en' | string;
}

/**
 * 直播播放器自动清晰度参数
 */
declare interface LivePlayerLevelAutoOptions {
    useLevelAuto?: boolean;
}

declare type LivePlayerLoaderResult = {
    type: 'html';
    create: PolyvLivePlayerFn;
} | {
    type: 'flash';
    create: PolyvObjectFn;
};

/**
 * 直播 mobile 播放器事件
 */
declare type LivePlayerMobileEvents = 's2j_onPlayerInitOver' | 'twiceEnd' | 's2j_onBarrageSettingClick' | 's2j_onFullScreen' | 's2j_onNormalScreen' | 'onHighlightsBtnClicked' | 'controlDisplay' | 'PLAYER_SKIN_INIT' | 'RT_SUBTITLE_CHANGE' | 'playerLoading' | 'PB_SUBTITLE_CHANGE' | 'PB_SUBTITLE_SELECT_CLICK' | 'MARQUEE_VALID_FAIL' | 'MARQUEE_CHECK_ERROR' | 'timeupdate' | 'setupChange' | 'SHOW_DETECTION_TIPS' | 'HIDE_DETECTION_TIPS' | 'DETECTION_SWITCH_SUCCESS' | 'fullscreenChange';

/**
 * 直播播放器多码率参数
 */
declare interface LivePlayerMultirateOptions {
    /** 默认清晰度，0-流程，1-高清，2-超清 */
    df?: number;
    /** 不显示多码率，默认：false */
    banMultirate?: boolean;
}

/**
 * 直播播放器参数选项
 */
declare interface LivePlayerOptions extends LivePlayerBaseOptions, LivePlayerDataOptions, LivePlayerPrivateOptions, LivePlayerBarrageOptions, LivePlayerUIOptions, LivePlayerLangOptions, LivePlayerVrOptions, LivePlayerAuthOptions, LivePlayerMultirateOptions, LivePlayerVolumeOptions, LivePlayerPlaybackOptions, LivePlayerFullScreenOptions, LivePlayerTimeShiftOptions, LivePlayerTimeAxisMarkOptions, LivePlayerOtherOptions, LivePlayerLevelAutoOptions, LivePlayerAdConfig, LivePlayerPictureInPictureOptions, Record<string, unknown> {
}

/**
 * 直播播放器-其他参数
 */
declare interface LivePlayerOtherOptions {
    /** flash 相关变量，但移动端播放器会读这个字段做一些处理 */
    flashvars?: {
        language?: LivePlayerLangOptions['language'];
        /** 直播流名称 */
        name?: string;
        /** 是否强制使用接口的 sessionId，默认：false */
        forceSessionId?: boolean;
    };
    /** 是否使用 ip 拉流 */
    ipPlay?: true;
    /** 获取微信 SDK 方法 */
    getWeixinSdk?: () => Promise<WechatJsSdk.Wx | undefined>;
}

/**
 * 直播 PC 播放器事件
 */
declare type LivePlayerPcEvents = 'onAutoPlay' | 's2j_onRateChanged' | 's2j_barrageStatus' | 'flowStatus' | 'enterpictureinpicture' | 'leavepictureinpicture';

declare interface LivePlayerPictureInPictureOptions {
    /** 是否开启小窗播放 */
    pictureInPictureEnabled?: boolean;
}

/**
 * 直播播放器回放参数
 */
declare interface LivePlayerPlaybackOptions {
    /** 回放地址 */
    vodsrc?: string;
    /** 回放总时长 */
    vodSrcDuration?: number;
}

/**
 * 直播播放器私有不对外公开参数
 */
declare interface LivePlayerPrivateOptions {
    /**
     * 是否请求源站的 channelJson，默认：false
     * @todo 通过 url 参数 betaLive 判断
     */
    beta_live?: boolean;
    /**
     * flash 播放器中请求源站的 channelJson，默认：false
     * @todo 通过 url 参数 betaLive 判断
     */
    beta_json?: boolean;
}

/**
 * 直播播放器-打点参数
 */
declare interface LivePlayerTimeAxisMarkOptions {
    /** 是否展示点位 */
    showPointBtn?: true;
}

declare interface LivePlayerTimeShiftOptions {
    /** 是否使用直播时移 */
    timeShift?: true;
    /** 直播开始时间，时间戳 */
    liveStartTime?: number;
}

/**
 * 直播播放器 UI 参数
 */
declare interface LivePlayerUIOptions {
    /** 是否显示控制栏（mobile） */
    hasControl?: boolean;
    /** 是否不显示默认皮肤（pc），默认：false */
    ban_ui?: boolean;
    /** 禁用片头广告（pc），默认：false */
    banPreAd?: boolean;
    /** 禁用片头广告（mobile）,默认：false */
    ban_ad?: boolean;
    /** 占位图皮肤设置 */
    skinConfig?: LivePlayerUISkinConfig;
    /** 皮肤类型 */
    skin_type?: 'black';
    /** 封面图缩放模式 */
    coverImgType?: 'cover' | 'contain';
    /** 直播时是否允许暂停 */
    banLivePause?: boolean;
}

/**
 * 直播播放器占位图皮肤设置
 */
declare interface LivePlayerUISkinConfig extends Record<string, unknown> {
    /** 设置无直播时的图标 */
    streamStop?: string;
    /** 设置无直播时的文案 */
    streamStopTxt?: string;
    /** 设置直播暂停时的图标 */
    streamPause?: string;
    /** 设置直播暂停时的文案 */
    streamPauseTxt?: string;
    /** 设置音频模式图标 */
    audioMode?: string;
    /** 整体的背景颜色 */
    bgColor?: string;
    /** 显示播放按钮，默认：true */
    showPlayBtn?: boolean;
    /** 显示全屏按钮，默认：true */
    showFullScreen?: boolean;
    /** 显示进度条，默认：true */
    showProgress?: boolean;
    /** 是否显示弹幕按钮（mobile），默认：true */
    showDanmuBtn?: boolean;
    /** 是否显示刷新按钮（mobile），默认：true */
    showRefreshBtn?: boolean;
    /** 是否显示线路切换按钮（mobile），默认：true */
    showLineBtn?: boolean;
    /** 是否显示清晰度按钮（mobile），默认：true */
    showClarityBtn?: boolean;
    /** 是否显示设置按钮（mobile），默认：true */
    showSetting?: boolean;
    /** 是否显示倍速按钮（mobile），默认：true */
    showRateBtn?: boolean;
}

/**
 * 直播播放器音量参数
 */
declare interface LivePlayerVolumeOptions {
    /** 隐藏静音提示（PC），默认：false */
    banMuteTips?: boolean;
}

/**
 * 直播播放器 VR 功能参数
 */
declare interface LivePlayerVrOptions {
    /** 是否开启 VR 功能（PC），默认：false */
    useVr?: boolean;
    /** 是否开启 VR 功能（mobile），默认：false */
    useVrMode?: boolean;
    panorjs?: string;
}

export declare interface LiveSquare {
    enabled: YN;
    title: string;
    linkType: string;
    link: string;
    jumpWay: string;
    pcLink: string;
    pcLinkJumpWay: string;
    mobileLink: string;
    wxMiniprogramOriginalId: string;
    wxMiniprogramAppId: string;
    wxMiniprogramLink: string;
    mobileAppLink: string;
    mobileAppLinkJumpWay: string;
    iosLink: string;
    androidLink: string;
    harmonyLink: string;
    otherLink: string;
}

/**
 * 频道直播状态
 */
export declare enum LiveStatus {
    /** 直播中 */
    Live = "live",
    /** 等待中 */
    Waiting = "waiting",
    /** 已结束，无直播 */
    End = "end",
    /** 回放中 */
    Playback = "playback",
    /** 直播暂停中 */
    Stop = "stop",
    /** 未开始 */
    UnStart = "unStart"
}

/**
 * 直播状态数据
 */
export declare interface LiveStatusData {
    /** 当前直播状态 */
    status: LiveStatus;
    /** 当前的场次号 */
    sessionId: string;
}

/**
 * 加载 SDK 灰度选项
 */
declare interface LoadSdkGrayOptions {
    /** 灰度开关 */
    grayEnabled: boolean;
    /** 灰度版本 */
    grayVersion: string;
}

declare interface LocalSteamInitOptions extends RtcStreamCommonOptions {
    /** 推流码率 */
    profile?: StreamProfile;
}

/**
 * 本地流对象
 */
declare interface LocalStreamInstance extends MicStreamInfo {
    /** 初始化本地流并推送 */
    init(options: LocalSteamInitOptions): Promise<void>;
}

/**
 * 弹幕位置类型
 * @desc top 顶部 bottom 底部 half 半屏 full 全屏
 */
export declare type LocationType = 'top' | 'bottom' | 'half' | 'full';

declare class Logger {
    private __interactionCore;
    private __elog?;
    /**
     * 初始化日志模块
     */
    constructor(__interactionCore: InteractionCore);
    private __init;
    /**
     * 构建日志信息
     * @param type 类型
     * @param module 模块
     * @param title 标题
     * @param content 内容
     */
    private __buildLogMessage;
    /**
     * 上报 log 级别事件
     * @api
     * @param module 模块
     * @param title 标题
     * @param content 内容
     */
    log(module: string, title: string, content?: string): void;
    /**
     * 上报 info 级别事件
     * @api
     * @param module 模块
     * @param title 标题
     * @param content 内容
     */
    info(module: string, title: string, content?: string): void;
    /**
     * 上报 warn 级别事件
     * @api
     * @param module 模块
     * @param title 标题
     * @param content 内容
     */
    warn(module: string, title: string, content?: string): void;
    /**
     * 上报 error 级别事件
     * @api
     * @param module 模块
     * @param title 标题
     * @param content 内容
     */
    error(module: string, title: string, content?: string): void;
}

/**
 * 日志模块名
 */
export declare enum LoggerName {
    /** debug 排查 */
    Debug = "debug",
    /** 快直播播放器模块 */
    LowLatencyPlayer = "low-latency-player",
    /** 连麦模块 */
    ConnectMic = "connect-mic",
    /** 微信模块 */
    Weixin = "wx",
    /** 微活动模块 */
    MicroActivity = "micro-activity",
    /** 火山无延迟模块 */
    VolcPlayer = "volc-player",
    /** 任务活动模块 */
    TaskActivity = "task-activity"
}

/**
 * 报名观看登录参数
 */
export declare interface LoginEnrollParams {
    /** 手机号 */
    phoneNumber?: string;
    /** 手机区号 */
    areaCode?: string;
    /** 短信验证码 */
    smsCode?: string;
    /** 邮箱 */
    email?: string;
}

export declare interface LoginIdentityInfoParams {
    /**
     * 手机号
     */
    phoneNumber?: string;
    /**
     * 手机区号
     */
    areaCode?: string;
    /**
     * 短信验证码
     */
    smsCode?: string;
}

/**
 * 登录登记观看参数
 */
export declare interface LoginInfoAuthParams {
    /**
     * 手机号
     */
    phoneNumber: string;
    /**
     * 手机区号
     */
    areaCode: string;
}

export declare namespace LoginInfoAuthRequest {
    export interface RequestData {
        /** 手机号，带区号格式 */
        mobile?: string;
    }
}

/**
 * 登录登记观看结果
 */
export declare type LoginInfoAuthResult = AuthVerifyResult<AuthType.Info>;

/**
 * 抽奖
 */
declare class Lottery extends InteractionBase_3 {
    PrizeAcceptType: typeof PrizeAcceptType;
    LotteryCondition: typeof LotteryCondition;
    LotteryRange: typeof LotteryRange;
    LotteryCustomGroupType: typeof LotteryCustomGroupType;
    LotteryReceiveFormType: typeof LotteryReceiveFormType;
    LotteryEvent: typeof LotteryEvent;
    LotteryStatus: typeof LotteryStatus;
    QuestionItemType: typeof QuestionItemType;
    AnswerQuestionType: typeof AnswerQuestionType;
    LotteryActivityDurationType: typeof LotteryActivityDurationType;
    LotteryMode: typeof LotteryMode;
    LotteryLaunchFailReason: typeof LotteryLaunchFailReason;
    eventEmitter: EventEmitter<LotteryEventRelations, LotteryEvent>;
    private __normalLotteryService;
    private __conditionLotteryService;
    launch: LotteryLaunchService;
    /**
     * 当前的抽奖列表
     */
    private __lotteryList;
    constructor(interactionCore: InteractionCore);
    private __initList;
    /* Excluded from this release type: appendLotteryList */
    /* Excluded from this release type: updateLotteryData */
    /* Excluded from this release type: removeLotteryData */
    /**
     * 获取当前抽奖活动列表
     *
     * 通过 `getLotteryList` 获取当前所有可用的抽奖活动列表。
     * @example
     * ```ts
     * const lotteryList = lotteryTarget.getLotteryList();
     * console.log('当前抽奖活动列表', lotteryList);
     * ```
     */
    getLotteryList(): LotteryBasicData[];
    /* Excluded from this release type: findLottery */
    /* Excluded from this release type: findLottery */
    /* Excluded from this release type: updateLotteryStatus */
    /* Excluded from this release type: startLottery */
    /* Excluded from this release type: finishLottery */
    /* Excluded from this release type: closeLottery */
    /**
     * 获取抽奖详情
     *
     * 通过 `getLotteryDetail` 获取指定抽奖活动的详细信息。
     * @param options 获取参数，包含抽奖ID和抽奖条件
     * @example
     * ```ts
     * const detail = await lotteryTarget.getLotteryDetail({ lotteryId: 'xxxx' });
     * console.log('抽奖详情', detail);
     * ```
     */
    getLotteryDetail(options: LotteryBasicOptions): Promise<LotteryDetail | undefined>;
    /**
     * 获取抽奖结果
     *
     * 在抽奖抽出了中奖结果之后，可调用该方法获取指定 `lotteryId` 的中奖结果。
     * @param options 获取参数，包含抽奖ID和抽奖条件
     * @example
     * ```ts
     * const lotteryResult = await lotteryTarget.getLotteryResult({ lotteryId: 'xxxx' });
     * console.log('抽奖结果', lotteryResult);
     * console.log('是否中奖', lotteryResult.isWinner);
     * console.log('奖品信息', lotteryResult.prizeInfo);
     * ```
     */
    getLotteryResult(options: LotteryBasicOptions): Promise<LotteryResult | undefined>;
    /**
     * 发送评论抽奖的评论内容
     *
     * 通过 `sendComment` 发送评论抽奖的评论内容。
     * @example
     * ```ts
     * await lotteryTarget.sendComment();
     * console.log('评论已发送');
     * ```
     */
    sendComment(): Promise<void>;
    /**
     * 检查评论的内容是否符合评论抽奖的条件
     *
     * 通过 `checkComment` 检查评论内容是否符合评论抽奖的条件。
     * @param comment 评论的内容
     * @example
     * ```ts
     * await lotteryTarget.checkComment('这是一条评论');
     * console.log('评论检查完成');
     * ```
     */
    checkComment(comment: string): Promise<void>;
    /**
     * 完成评论抽奖
     *
     * 通过 `finishComment` 完成评论抽奖流程。
     * @example
     * ```ts
     * await lotteryTarget.finishComment();
     * console.log('评论抽奖已完成');
     * ```
     */
    finishComment(): Promise<void>;
    /**
     * 开始答题
     *
     * 通过 `startAnswer` 开始答题抽奖流程。
     * @example
     * ```ts
     * const result = await lotteryTarget.startAnswer();
     * console.log('答题开始，当前正在答题的题目 id', result.questionId);
     * ```
     */
    startAnswer(): Promise<StartLotteryAnswerResult>;
    /**
     * 获取最近一次的答题结果
     *
     * 通过 `getLastAnswerResult` 获取最近一次的答题结果。
     * @example
     * ```ts
     * const result = await lotteryTarget.getLastAnswerResult();
     * console.log('最近答题结果', result);
     * console.log('是否正确', result.result);
     * ```
     */
    getLastAnswerResult(): Promise<AnswerResultData | undefined>;
    /**
     * 提交答题
     *
     * 通过 `submitAnswer` 提交答题抽奖的答案。
     * @param params 提交答题参数
     * @example
     * ```ts
     * const result = await lotteryTarget.submitAnswer({
     *   questionId: 'xxxx',
     *   answer: 'ab'
     * });
     * console.log('答题提交结果', result);
     * console.log('是否正确', result.result);
     * ```
     */
    submitAnswer(params: SubmitAnswerParams): Promise<SubmitAnswerResult_2>;
    /**
     * 获取个人中奖记录
     *
     * 通过 `getPersonalWinning` 获取当前观众的中奖列表，并显示到页面。
     * @example
     * ```ts
     * const data = await lotteryTarget.getPersonalWinning({ pageNumber: 1 });
     * console.log('中奖记录列表', data.contents);
     * ```
     */
    getPersonalWinning(options?: PageOptions): Promise<PageContent_2<LotteryRecordData>>;
    /**
     * 获取中奖领取信息
     *
     * 通过 `lotteryId` 获取该次抽奖的中奖信息，用于显示信息填写、二维码、链接等交互。
     * @param options 获取参数
     * @example
     * ```js
     * import { PrizeAcceptType } from '@polyv/lottery-sdk';
     * const receiveData = await lotteryTarget.getLotteryReceive({ lotteryId: 'xxxx' });
     *
     * console.log('领取方式：', receiveData.acceptType);
     * console.log('表单结构与中奖截止时间：', receiveData.formList, receiveData.overTime);
     * console.log('领取链接：', receiveData.prizeUrl);
     * console.log('二维码信息：', receiveData.qrCode, receiveData.qrCodeTips);
     * ```
     */
    getLotteryReceive(options: {
        /** 抽奖 id */
        lotteryId: string;
    }): Promise<LotteryReceiveData>;
    /**
     * 提交领取信息
     *
     * 当中奖设置了需要采集中奖信息后，可通过 `submitReceive` 提交中奖者的领取信息。
     * @param options 提交参数
     * @example
     * ```js
     * const receiveInfo = [
     *   { field: '姓名', value: '张三' },
     *   { field: '手机', value: '18012345678' },
     *   { field: '地址', value: '广东省广州市番禺区xxxx' }
     * ];
     *
     * await lotteryTarget.submitReceive({
     *   lotteryId: 'xxxx',
     *   winnerCode: 'xxxx',
     *   receiveInfo,
     * });
     * toast('提交成功');
     * ```
     */
    submitReceive(options: SubmitReceiveOptions): Promise<void>;
    /**
     * 获取中奖者分组列表
     *
     * 通过 `getLotteryWinnersGroup` 获取中奖者分组列表，用于显示到页面。
     * @param options 获取参数
     * @example
     * ```ts
     * const data = await lotteryTarget.getLotteryWinnersGroup({ lotteryId: 'xxxx' });
     * console.log('中奖者分组列表', data);
     *
     * // 通过分组 id 获取中奖者列表
     * const winners = await lotteryTarget.getLotteryWinners({ lotteryId: 'xxxx', groupId: data[0].id });
     * console.log('中奖者列表', winners.contents);
     * ```
     */
    getLotteryWinnersGroup(options: {
        lotteryId: string;
    }): Promise<LotteryWinnersGroup[]>;
    /**
     * 获取中奖者列表
     *
     * 通过 `getLotteryWinners` 获取指定抽奖活动的中奖者列表。
     * @param options 获取参数，包含抽奖ID、分组ID、页码和每页数量
     * @example
     * ```ts
     * const data = await lotteryTarget.getLotteryWinners({ lotteryId: 'xxxx' });
     * console.log('中奖者列表', data.contents);
     * ```
     */
    getLotteryWinners(options: GetLotteryWinnersOptions): Promise<PageContent_2<LotteryWinnersData>>;
}

declare interface LotteryActivityData {
    /**
     * 活动 id
     */
    id: number;
    /**
     * 活动名称
     */
    activityName: string;
    /**
     * 活动时长
     */
    activityDuration: number | '';
    /**
     * 活动时长类型
     */
    activityDurationType: LotteryActivityDurationType;
    /**
     * 抽奖条件
     */
    lotteryCondition: LotteryCondition;
    /**
     * 奖品名称
     */
    prizeName: string;
    /**
     * 奖品列表
     */
    prizeList: LotteryLaunchPrizeForm[];
    /**
     * 中奖人数
     */
    amount: number;
    /**
     * 表单信息
     */
    formData: Required<LotteryLaunchForm>;
    /**
     * 原数据
     */
    originalData: unknown;
}

declare enum LotteryActivityDurationType {
    /**
     * 时
     */
    Hour = "hour",
    /**
     * 分钟
     */
    Minute = "minute",
    /**
     * 秒
     */
    Second = "second"
}

/**
 * 抽奖基础数据
 */
declare interface LotteryBasicData {
    /**
     * 抽奖 id
     */
    lotteryId: string;
    /**
     * 抽奖条件
     */
    lotteryCondition: LotteryCondition;
    /**
     * 抽奖状态
     */
    lotteryStatus: LotteryStatus;
    /**
     * 抽奖时间，单位：时间戳，如果为 0 表示即刻抽奖或已过开始抽奖时间
     */
    lotteryTime: number;
    /**
     * 奖品数量
     */
    prizeCount: number;
}

declare interface LotteryBasicOptions {
    lotteryId: string;
    subLotteryId?: string;
    lotteryCondition?: LotteryCondition;
}

/**
 * 抽奖条件
 */
declare enum LotteryCondition {
    /**
     * 无条件
     */
    None = "none",
    /**
     * 评论
     */
    Comment = "comment",
    /**
     * 观看时长
     */
    Duration = "duration",
    /**
     * 邀请抽奖
     */
    Invite = "invite",
    /**
     * 答题
     */
    Answer = "question",
    /**
     * 问卷
     */
    Questionnaire = "questionnaire"
}

declare interface LotteryConditionBase<C extends LotteryCondition> {
    /**
     * 抽奖条件
     */
    lotteryCondition: C;
    /**
     * 是否有资格参加
     */
    hasEligible: boolean;
    /**
     * 是否已达成
     */
    isAchieved: boolean;
}

/**
 * 抽奖条件数据
 */
declare type LotteryConditionData = NoneCondition | CommentCondition | DurationCondition | InviteCondition | AnswerCondition | QuestionnaireCondition;

declare interface LotteryCustomGroupItem {
    /**
     * 分组 id
     */
    id: number;
    /**
     * 分组名称
     */
    title: string;
    /**
     * 分组人数
     */
    count: number;
}

/**
 * 分组抽奖的中奖类型
 */
declare enum LotteryCustomGroupType {
    /**
     * 随机抽奖
     */
    Random = "random",
    /**
     * 等额抽奖
     */
    Average = "average",
    /**
     * 分组自定义
     */
    Specified = "specified"
}

/**
 * 抽奖详情
 */
declare interface LotteryDetail {
    /**
     * 抽奖 id
     */
    lotteryId: string;
    /**
     * 抽奖状态
     */
    lotteryStatus: LotteryStatus;
    /**
     * 抽奖时间，单位：时间戳，如果为 0 表示即刻抽奖或已过开始抽奖时间
     */
    lotteryTime: number;
    /**
     * 抽奖条件
     */
    condition: LotteryConditionData;
    /**
     * 奖品列表
     */
    prizeList: LotteryPrizeDetail[];
    /**
     * 是否显示参与人数
     */
    showJoinCount: boolean;
    /**
     * 参与人数
     */
    joinCount: number;
    /**
     * 活动名称
     */
    activityName: string;
}

/**
 * 抽奖事件
 * @eventenum {@link LotteryEventRelations}
 */
declare enum LotteryEvent {
    /**
     * 抽奖初始化完成
     *
     * 在获取抽奖列表后触发，触发后可调用抽奖相关的 Api，如获取抽奖列表。
     * @example
     * ```js
     * lotteryTarget.eventEmitter.on(LotteryEvent.LotteryInited, (data) => {
     *   console.log('当前进行中的抽奖列表', data.lotteryList);
     * });
     * ```
     */
    LotteryInited = "LotteryInited",
    /**
     * 抽奖列表更新
     *
     * 当抽奖列表改变时触发该事件，如发起了新的抽奖、抽奖状态改变等。
     * @example
     * ```js
     * lotteryTarget.eventEmitter.on(LotteryEvent.LotteryListUpdate, (data) => {
     *   console.log('更新后的抽奖列表', data.lotteryList);
     * });
     * ```
     */
    LotteryListUpdate = "LotteryListUpdate",
    /**
     * 发起抽奖
     *
     * 当发起新的抽奖时触发该事件。
     * @example
     * ```js
     * lotteryTarget.eventEmitter.on(LotteryEvent.LotteryInitiate, (data) => {
     *   console.log('抽奖ID', data.lotteryId);
     *   console.log('抽奖条件', data.lotteryCondition);
     *   console.log('抽奖状态', data.lotteryStatus);
     *   console.log('抽奖时间', data.lotteryTime);
     * });
     * ```
     */
    LotteryInitiate = "LotteryInitiate",
    /**
     * 开始抽奖
     *
     * 当抽奖开始时触发该事件。
     * @example
     * ```js
     * lotteryTarget.eventEmitter.on(LotteryEvent.LotteryStart, (data) => {
     *   console.log('开始抽奖的ID', data.lotteryId);
     * });
     * ```
     */
    LotteryStart = "LotteryStart",
    /**
     * 抽奖结果
     *
     * 当抽奖结果产生时触发该事件。
     * @example
     * ```js
     * lotteryTarget.eventEmitter.on(LotteryEvent.LotteryResult, (data) => {
     *   console.log('是否中奖', data.lotteryResult.isWinner);
     *   console.log('奖品信息', data.lotteryResult.prizeInfo);
     * });
     * ```
     */
    LotteryResult = "LotteryResult",
    /**
     * 抽奖完成
     *
     * 当抽奖流程完成时触发该事件。
     * @example
     * ```js
     * lotteryTarget.eventEmitter.on(LotteryEvent.LotteryFinish, (data) => {
     *   console.log('完成的抽奖ID', data.lotteryId);
     * });
     * ```
     */
    LotteryFinish = "LotteryFinish",
    /**
     * 抽奖关闭
     *
     * 当抽奖被关闭时触发该事件。
     * @example
     * ```js
     * lotteryTarget.eventEmitter.on(LotteryEvent.LotteryClose, (data) => {
     *   console.log('关闭的抽奖ID', data.lotteryId);
     * });
     * ```
     */
    LotteryClose = "LotteryClose",
    /**
     * 抽奖详情更新
     *
     * 当抽奖详情信息发生更新时触发该事件。
     * @example
     * ```js
     * lotteryTarget.eventEmitter.on(LotteryEvent.DetailUpdate, (data) => {
     *   console.log('更新后的抽奖详情', data.lotteryDetail);
     * });
     * ```
     */
    DetailUpdate = "DetailUpdate",
    /**
     * 添加题目
     *
     * 当答题抽奖中，发起端推送了新的题目时触发该事件。
     * @example
     * ```js
     * lotteryTarget.eventEmitter.on(LotteryEvent.AddQuestion, (data) => {
     *   console.log('抽奖ID', data.lotteryId);
     *   console.log('新增的题目', data.question);
     * });
     * ```
     */
    AddQuestion = "AddQuestion"
}

/**
 * 抽奖时间回调参数
 */
declare type LotteryEventRelations = {
    [LotteryEvent.LotteryInited]: {
        lotteryList: LotteryBasicData[];
    };
    [LotteryEvent.LotteryListUpdate]: {
        /**
         * 当前抽奖活动的列表
         */
        lotteryList: LotteryBasicData[];
    };
    [LotteryEvent.LotteryInitiate]: LotteryBasicData;
    [LotteryEvent.LotteryStart]: {
        /**
         * 抽奖 id
         */
        lotteryId: string;
    };
    [LotteryEvent.LotteryResult]: {
        lotteryResult: LotteryResult;
    };
    [LotteryEvent.LotteryFinish]: {
        /**
         * 抽奖 id
         */
        lotteryId: string;
    };
    [LotteryEvent.LotteryClose]: {
        /**
         * 抽奖 id
         */
        lotteryId: string;
    };
    [LotteryEvent.DetailUpdate]: {
        /**
         * 抽奖详情
         */
        lotteryDetail: LotteryDetail;
    };
    [LotteryEvent.AddQuestion]: {
        /**
         * 抽奖 id
         */
        lotteryId: string;
        /**
         * 题目
         */
        question: AnswerQuestionItem;
    };
};

/**
 * 抽奖失败原因
 */
declare enum LotteryFailReason {
    /**
     * 未知
     */
    Unknown = "unknown"
}

declare type LotteryInviteType = 'poster' | 'external';

declare interface LotteryLaunchCustomGroupItem {
    /**
     * 分组 id
     */
    id: number;
    /**
     * 分组名称
     */
    title: string;
    /**
     * 分组人数
     */
    count: number;
    /**
     * 分组自定义抽奖下的每组中奖人数，`customGroupLotteryType` 为 `LotteryCustomGroupType.Specified` 时必填
     */
    amount: number;
}

/**
 * 抽奖发起失败原因
 */
declare enum LotteryLaunchFailReason {
    Unknown = "unknown"
}

/**
 * 抽奖发起表单数据
 */
declare interface LotteryLaunchForm extends LotteryLaunchFormBase, LotteryLaunchFormCondition, LotteryLaunchFormTime, LotteryLaunchFormRange {
    /**
     * 奖品列表
     */
    prizeList?: LotteryLaunchPrizeForm[];
}

declare interface LotteryLaunchFormBase {
    /**
     * 活动名称
     */
    activityName?: string;
    /**
     * 允许重复中奖
     */
    repeatWinEnabled?: boolean;
    /**
     * 兑换码
     */
    showWinnerCode?: boolean;
    /**
     * 中奖名单
     */
    showWinners?: boolean;
}

declare interface LotteryLaunchFormCondition {
    /**
     * 参与条件
     */
    lotteryCondition: LotteryCondition;
    /**
     * 评论内容
     *
     * 当 `lotteryCondition` 为 `LotteryCondition.Comment` 时必填
     */
    comment?: string;
    /**
     * 观看时长，单位：分钟
     *
     * 当 `lotteryCondition` 为 `LotteryCondition.Duration` 时必填
     */
    duration?: number | '';
    /**
     * 邀请人数
     *
     * 当 `lotteryCondition` 为 `LotteryCondition.Invite` 时必填
     */
    inviteNum?: number | '';
    /**
     * 邀请方式
     *
     * 当 `lotteryCondition` 为 `LotteryCondition.Invite` 时必填
     */
    inviteType?: LotteryInviteType;
    /**
     * 答题方式
     *
     * 当 `lotteryCondition` 为 `LotteryCondition.Answer` 时必填
     */
    answerType?: AnswerQuestionType;
    /**
     * 每道题的答题时间
     *
     * 当 `lotteryCondition` 为 `LotteryCondition.Answer` 时必填
     */
    perAnswerDuration?: number | '';
    /**
     * 答题问卷 id
     *
     * 当 `lotteryCondition` 为 `LotteryCondition.Answer` 时必填
     */
    answerQuestionnaireId?: number | '';
    /**
     * 答题问卷
     *
     * 当 `lotteryCondition` 为 `LotteryCondition.Answer` 时必填
     */
    answerQuestionnaire?: LotteryLaunchFormQuestionnaireInfo | null;
    /**
     * 问卷 id
     *
     * 当 `lotteryCondition` 为 `LotteryCondition.Questionnaire` 时必填
     */
    questionnaireId?: number | '';
    /**
     * 问卷信息
     *
     * 当 `lotteryCondition` 为 `LotteryCondition.Questionnaire` 时必填
     */
    questionnaireInfo?: LotteryLaunchFormQuestionnaireInfo | null;
}

/**
 * 问卷选择信息
 */
declare interface LotteryLaunchFormQuestionnaireInfo {
    /**
     * 问卷 id
     */
    questionnaireId: number;
    /**
     * 问卷标题
     */
    title: string;
    /**
     * 题目数量
     */
    questionCount: number;
}

/**
 * 抽奖发起表单数据：中奖范围
 */
declare interface LotteryLaunchFormRange {
    /**
     * 参与用户类型
     */
    lotteryRange: LotteryRange;
    /**
     * 中奖人数，当 `lotteryRange` 为 `LotteryRange.All` 时必填
     */
    amount?: number | '';
    /**
     * 自定义分组列表
     *
     * 当 `lotteryRange` 为 `LotteryRange.CustomGroup` 时必填
     */
    customGroupList?: LotteryLaunchCustomGroupItem[];
    /**
     * 自定义分组下的中奖类型
     */
    customGroupLotteryType?: LotteryCustomGroupType;
    /**
     * 自定义分组下的中奖人数
     */
    customGroupLotteryAmount?: number | '';
    /**
     * 标签用户 id 列表，当 `lotteryRange` 为 `LotteryRange.UserLabel` 时必填
     */
    userLabels?: ViewerLabelItem[];
    /**
     * 标签用户下的中奖人数
     */
    userLabelAmount?: number | '';
    /**
     * 是否开启预设中奖
     */
    presetEnabled?: boolean;
    /**
     * 预设中奖列表
     */
    presetList?: LotteryLaunchPresetInfo[];
    /**
     * 是否隐藏参与用户
     */
    hiddenAttendeeNumber?: boolean;
    /**
     * 是否隐藏中奖人数
     */
    hiddenWinnerAmount?: boolean;
    /**
     * 是否在线
     */
    lotteryOnlineEnabled?: boolean;
}

/**
 * 抽奖发起表单数据：抽奖时间
 */
declare interface LotteryLaunchFormTime {
    /**
     * 抽奖模式
     */
    lotteryMode: LotteryMode;
    /**
     * 活动开始时间
     */
    activityStartTime?: number | '';
    /**
     * 活动时长
     */
    activityDuration?: number | '';
    /**
     * 活动时长类型
     */
    activityDurationType?: LotteryActivityDurationType;
}

declare interface LotteryLaunchPresetInfo {
    /**
     * 用户 id
     */
    userId: string;
    /**
     * 昵称
     */
    nickname: string;
}

declare interface LotteryLaunchPrizeForm {
    /**
     * 答题数量
     *
     * 答题抽奖时配置
     */
    correctAnswerCount?: number | '';
    /**
     * 中奖人数
     */
    amount?: number | '';
    /**
     * 是否隐藏中奖人数
     */
    hiddenWinnerAmount?: boolean;
    /**
     * 奖品名称
     */
    prize: string;
    /**
     * 奖项
     */
    prizeLevel: string;
    /**
     * 缩略图
     */
    thumbnail: string;
    /**
     * 优惠价
     */
    realPrice: number | '';
    /**
     * 原价
     */
    originPrice: number | '';
    /**
     * 奖品是否可以领取
     */
    receiveEnabled: boolean;
    /**
     * 领取方式
     */
    acceptType: PrizeAcceptType;
    /**
     * 信息采集表单信息
     */
    formInfo: LotteryLaunchPrizeFormInfoItem[];
    /**
     * 是否开启提交截止时间
     */
    overTimeEnabled: boolean;
    /**
     * 提交截止时间
     */
    overTime: number | '';
    /**
     * 跳转地址
     */
    prizeUrl: string;
    /**
     * 二维码地址
     */
    qrCode: string;
    /**
     * 二维码提示
     */
    qrCodeTips: string;
}

declare interface LotteryLaunchPrizeFormInfoItem {
    /** 标题 */
    field: string;
    /** 表单类型 */
    type: LotteryReceiveFormType;
    /** 提示 */
    tips: string;
    /** 是否必填 */
    required: boolean;
}

/**
 * 抽奖发起记录数据
 */
declare interface LotteryLaunchRecordData {
    /**
     * 抽奖 id
     */
    lotteryId: string;
    /**
     * 活动名称
     */
    activityName: string;
    /**
     * 抽奖状态
     */
    lotteryStatus: LotteryStatus;
    /**
     * 奖品名称
     */
    prizeName: string;
    /**
     * 抽奖条件
     */
    lotteryCondition: LotteryCondition;
    /**
     * 中奖总人数
     */
    amount: number;
    /**
     * 活动开始时间
     */
    activityStartTime: number | null;
    /**
     * 活动结束时间
     */
    activityEndTime: number | null;
    /**
     * 活动时长
     */
    activityDuration: number | null;
    /**
     * 活动时长类型
     */
    activityDurationType: LotteryActivityDurationType;
    /**
     * 抽奖范围
     */
    lotteryRange: LotteryRange;
    /**
     * 抽奖分组类型
     */
    customGroupLotteryType: LotteryCustomGroupType | null;
    /**
     * 如果是问卷抽奖，则为设置的问卷 id
     */
    questionnaireId?: string;
    /**
     * 奖品列表
     */
    prizeList: LotteryLaunchRecordPrizeData[];
    /**
     * 题目总数
     */
    questionCount: number;
    /**
     * 当前题目索引
     */
    questionIndex: number;
    /**
     * 答题方式
     */
    answerType: AnswerQuestionType;
    /**
     * 答题抽奖时，是否可以答题
     */
    answerStatus: boolean;
    /**
     * 原数据
     */
    originalData: unknown;
}

declare interface LotteryLaunchRecordPrizeData {
    /**
     * 奖品的抽奖 id
     */
    lotteryId: string;
    /**
     * 奖品名称
     */
    prize: string;
    /**
     * 奖项
     */
    prizeLevel: string;
    /**
     * 奖品状态，lottery-已开奖、wait-待开奖
     */
    status: 'lottery' | 'wait';
}

/**
 * 抽奖发起端服务
 */
declare class LotteryLaunchService {
    private __lotteryTarget;
    constructor(__lotteryTarget: Lottery);
    /**
     * 获取自定义分组列表
     */
    getCustomGroupList(): Promise<LotteryCustomGroupItem[]>;
    /**
     * 搜索用户列表
     */
    searchUserList(options: SearchUserListOptions): Promise<LotteryLaunchPresetInfo[]>;
    /**
     * 判断当前频道人数是否小于参与人数
     * @param formData 抽奖发起表单数据
     */
    isLessThanJoinCount(formData: LotteryLaunchForm): Promise<boolean>;
    /**
     * 发起抽奖
     * @param formData 抽奖表单
     */
    startLottery(formData: LotteryLaunchForm): Promise<CommonResult_2<LotteryLaunchFailReason>>;
    /**
     * 获取管理后台预设的抽奖活动列表
     */
    getActivityList(): Promise<LotteryActivityData[]>;
    /**
     * 获取抽奖历史记录
     */
    getLotteryRecordList(options: PageOptions): Promise<PageContent_2<LotteryLaunchRecordData>>;
    /**
     * 获取抽奖中的参与人数
     */
    getLotteryViewerSize(options: GetLotteryViewerSizeOptions): Promise<{
        lotteryId: string;
        size: number;
    }>;
    /**
     * 取消抽奖
     */
    cancelLottery(lotteryId: string): Promise<void>;
    /**
     * 开奖
     */
    openLottery(lotteryId: string, subLotteryId?: string): Promise<CommonResult_2<LotteryLaunchFailReason>>;
    /**
     * 获取中奖者分组列表
     */
    getLotteryWinnersGroup(options: {
        lotteryId: string;
    }): Promise<LotteryWinnersGroup[]>;
    /**
     * 获取抽奖中奖名单
     */
    getLotteryWinners(options: GetLotteryWinnersOptions): Promise<PageContent_2<LotteryWinnersData>>;
    /**
     * 获取抽奖可选的用户标签列表
     */
    getViewerLabelList(options?: GetViewerLabelListOptions): Promise<PageContent_2<ViewerLabelItem>>;
    /**
     * 推送答题题目
     * @param lotteryId 抽奖 id
     */
    pushAnswerQuestion(lotteryId: string): Promise<void>;
    /**
     * 获取答题抽奖问卷模版信息
     * @param questionnaireId 问卷模板 id
     */
    getAnswerQuestionnaireTemplate(questionnaireId: number): Promise<LotteryLaunchFormQuestionnaireInfo>;
    /**
     * 获取问卷抽奖问卷模版信息
     * @param questionnaireId 问卷模板 id
     */
    getQuestionnaireTemplate(questionnaireId: number): Promise<LotteryLaunchFormQuestionnaireInfo>;
}

declare enum LotteryMode {
    /**
     * 即时抽奖
     */
    Immediate = "immediate",
    /**
     * 定时抽奖（手动结束）
     */
    ScheduledManual = "wait",
    /**
     * 定时抽奖（自动结束）
     */
    ScheduledAuto = "task"
}

export declare interface LotteryPrivacyDetail {
    /** 抽奖隐私协议内容 */
    privacyContent: string | undefined;
    /** 抽奖活动隐私协议开关 */
    lotteryActivityPrivacyEnabled: YN;
}

/**
 * 抽奖奖品详情
 */
declare interface LotteryPrizeDetail extends LotteryPrizeInfo {
    /**
     * 奖品的抽奖 id
     */
    lotteryId: string;
    /**
     * 是否显示中奖人数
     */
    showWinnerCount: boolean;
    /**
     * 中奖人数
     */
    winnerCount: number;
    /**
     * 是否已开奖
     */
    lotteryed: boolean;
}

/**
 * 抽奖奖品信息
 */
declare interface LotteryPrizeInfo {
    /**
     * 奖品名称
     */
    prize: string;
    /**
     * 奖项
     */
    prizeLevel?: string;
    /**
     * 缩略图
     */
    thumbnail?: string;
    /**
     * 优惠价
     */
    realPrice?: number;
    /**
     * 原价
     */
    originPrice?: number;
}

/**
 * 抽奖范围
 */
declare enum LotteryRange {
    /**
     * 全体在线用户
     */
    All = "all",
    /**
     * 自定义分组
     */
    CustomGroup = "customGroup",
    /**
     * 标签用户
     */
    UserLabel = "userLabel"
}

/**
 * 抽奖领取信息
 */
declare interface LotteryReceiveData {
    /**
     * 奖品信息
     */
    prizeInfo: LotteryPrizeInfo;
    /**
     * 领奖方式
     */
    acceptType: PrizeAcceptType;
    /**
     * 表单列表
     */
    formList: LotteryReceiveFormItem[];
    /**
     * 是否已领取
     */
    received: boolean;
    /**
     * 抽奖 id
     */
    lotteryId: string;
    /**
     * 抽奖条件
     */
    lotteryCondition: LotteryCondition;
    /**
     * 奖品领取地址
     */
    prizeUrl: string | null;
    /**
     * 二维码地址
     */
    qrCode: string;
    /**
     * 二维码提示
     */
    qrCodeTips: string;
    /**
     * 兑换码
     */
    winnerCode: string;
    /**
     * 是否显示兑换码
     */
    showWinnerCode: boolean;
    /**
     * 中奖信息提交截止时间
     */
    overTime: number | null;
}

/**
 * 领取信息表单节点
 */
declare interface LotteryReceiveFormItem {
    /** 标题 */
    field: string;
    /** 表单类型 */
    formType: LotteryReceiveFormType;
    /** 提示 */
    tips: string;
    /** 是否必填 */
    required: boolean;
    /** 填写的值 */
    value: string | null;
}

/**
 * 抽奖表单填写类型
 */
declare enum LotteryReceiveFormType {
    /**
     * 姓名
     */
    Name = "userName",
    /**
     * 手机号码
     */
    Phone = "userPhone",
    /**
     * 自定义
     */
    Custom = "custom",
    /**
     * 地址
     */
    Address = "address"
}

/**
 * 中奖记录数据
 */
declare interface LotteryRecordData {
    /**
     * 抽奖 id
     */
    lotteryId: string;
    /**
     * 抽奖条件
     */
    lotteryCondition: LotteryCondition;
    /**
     * 奖品信息
     */
    prizeInfo: LotteryPrizeInfo;
    /**
     * 兑换码
     */
    winnerCode: string;
    /**
     * 是否显示中奖码
     */
    showWinnerCode: boolean;
    /**
     * 是否显示领取按钮
     */
    showReceive: boolean;
    /**
     * 是否已提交信息
     */
    received: boolean;
    /**
     * 中奖时间
     */
    winningTime: number;
    /**
     * 中奖采集方式
     */
    acceptType: PrizeAcceptType;
}

/**
 * 抽奖结果
 */
declare interface LotteryResult {
    /**
     * 抽奖 id
     */
    lotteryId: string;
    /**
     * 活动名称
     */
    activityName: string;
    /**
     * 抽奖条件
     */
    lotteryCondition: LotteryCondition;
    /**
     * 抽奖范围
     */
    lotteryRange: LotteryRange;
    /**
     * 分组抽奖类型
     */
    customGroupLotteryType: LotteryCustomGroupType;
    /**
     * 是否中奖
     */
    isWinner: boolean;
    /**
     * 奖品信息
     */
    prizeInfo: LotteryPrizeInfo;
    /**
     * 兑换码
     */
    winnerCode: string;
    /**
     * 是否显示中奖码
     */
    showWinnerCode: boolean;
    /**
     * 是否显示领取按钮
     */
    showReceive: boolean;
    /**
     * 奖品领取的抽奖 id
     */
    receiveLotteryId: string;
    /**
     * 是否显示参与人数
     */
    showJoinCount: boolean;
    /**
     * 参与人数
     */
    joinCount: number;
    /**
     * 是否显示中奖人数
     */
    showWinnerCount: boolean;
    /**
     * 中奖人数
     */
    winnerCount: number;
    /**
     * 是否显示中奖名单
     */
    showWinners: boolean;
    /**
     * 中奖采集方式
     */
    acceptType: PrizeAcceptType;
    /**
     * 中奖信息提交截止时间
     */
    overTime?: number;
}

/**
 * 抽奖状态
 */
declare enum LotteryStatus {
    /**
     * 等待抽奖/未开始
     */
    Waiting = "waiting",
    /**
     * 开奖中/进行中
     */
    Drawing = "drawing",
    /**
     * 已完成/已结束
     */
    Finished = "finshed",
    /**
     * 已取消
     */
    Cancel = "cancel"
}

declare interface LotteryWinnersData {
    /**
     * 观众名称
     */
    viewerName: string;
}

/**
 * 抽奖分组信息
 */
declare interface LotteryWinnersGroup {
    /**
     * 分组id
     */
    id: number;
    /**
     * 分组名称
     */
    title: string;
    /**
     * 中奖人数
     */
    count: number;
}

declare class LuckyLottery extends InteractionBase_5 {
    static appName: string;
    LuckyLotteryTemplate: typeof LuckyLotteryTemplate;
    LuckyLotteryEvent: typeof LuckyLotteryEvent;
    PrizeType: typeof PrizeType;
    PrizeAcceptType: typeof PrizeAcceptType_2;
    eventEmitter: EventEmitter<LuckyLotteryEventRelations, LuckyLotteryEvent>;
    private __luckyLotteryEnabled;
    /**
     * 获取平台抽奖活动是否进行中
     * @example
     * ```js
     * const enabled = luckyLotteryTarget.getLuckyLotteryEnabled();
     * console.log('平台抽奖活动是否进行中', enabled);
     * ```
     */
    getLuckyLotteryEnabled(): boolean;
    constructor(interactionCore: InteractionCore);
    private __processSocketCache;
    /**
     * 聊天室初始化事件，判断当前是否存在进行中的抽奖活动
     */
    private __onSliceID;
    /**
     * 开始抽奖活动
     */
    private __onStartLuckyLotteryTask;
    /**
     * 结束抽奖活动
     */
    private __onEndLuckyLotteryTask;
    /**
     * 开始抽奖活动
     * 调用 `startLuckyLottery` 开始抽奖
     * @param activityId 活动ID
     * @example
     * ```ts
     * const result = await luckyLotteryTarget.startLuckyLottery(123);
     * if (result.success) {
     *   console.log('抽奖成功', result.data);
     * } else {
     *   console.error('抽奖失败', result.failReason);
     * }
     * ```
     */
    startLuckyLottery(activityId: number): Promise<CommonResult_2<string, {
        data: LuckyLotteryResult;
    }>>;
    /**
     * 获取幸运抽奖活动列表
     * 通过 `getLuckyLotteryActivityList` 获取幸运抽奖活动列表，并显示到页面。
     * @param options 分页参数
     * @example
     * ```ts
     * const data = await luckyLotteryTarget.getLuckyLotteryActivityList({ pageNumber: 1, pageSize: 10 });
     * console.log('幸运抽奖活动列表', data.contents);
     * ```
     */
    getLuckyLotteryActivityList(options?: PageOptions): Promise<PageContent_2<LuckyLotteryActivityItem>>;
    /**
     * 获取幸运抽奖活动详情
     * 通过 `getLuckyLotteryActivityById` 获取幸运抽奖活动详情，并显示到页面。
     * @param activityId 活动ID
     * @example
     * ```ts
     * const data = await luckyLotteryTarget.getLuckyLotteryActivityById(123);
     * console.log('幸运抽奖活动详情', data);
     * ```
     */
    getLuckyLotteryActivityById(activityId: number): Promise<LuckyLotteryActivityDetailData>;
    /**
     * 获取中奖者列表
     * 通过 `getLuckyLotteryWinnersList` 获取当前抽奖活动的中奖者列表，并显示到页面。
     * @param options 获取参数，包含分页信息和活动ID
     * @example
     * ```ts
     * const data = await luckyLotteryTarget.getLuckyLotteryWinnersList({
     *   pageNumber: 1,
     *   pageSize: 10,
     *   taskId: 123
     * });
     * console.log('中奖者列表', data.contents);
     * ```
     */
    getLuckyLotteryWinnersList(options: PageOptions & {
        taskId: number;
    }): Promise<PageContent_2<LuckyLotteryWinnersItem>>;
    /**
     * 获取幸运抽奖中奖记录
     * 通过 `getLuckyLotteryPrizeList` 获取当前用户的中奖记录列表，并显示到页面。
     * @param options 获取参数，包含分页信息
     * @example
     * ```ts
     * const data = await luckyLotteryTarget.getLuckyLotteryPrizeList({
     *   pageNumber: 1,
     *   pageSize: 10
     * });
     * console.log('奖品列表', data.contents);
     * ```
     */
    getLuckyLotteryPrizeList(options?: PageOptions): Promise<PageContent_2<LuckyLotteryPrizeItem>>;
    /**
     * 获取中奖领取信息
     * 通过 `getLuckyLotteryReceive` 获取中奖领取信息，并显示到页面。
     * @param recordId 中奖记录行 ID
     * @example
     * ```ts
     * const data = await luckyLotteryTarget.getLuckyLotteryReceive(123);
     * console.log('中奖领取信息', data);
     * ```
     */
    getLuckyLotteryReceive(recordId: number): Promise<LuckyLotteryReceiveData>;
    /**
     * 提交中奖领取信息
     * 通过 `submitLuckyLotteryReceive` 提交中奖领取信息，并显示到页面。
     * @param options 提交参数
     * @example
     * ```ts
     * await luckyLotteryTarget.submitLuckyLotteryReceive({
     *   taskId: 123,
     *   recordId: 123,
     *   collectItems: [{ field: '姓名', type: 'text', tips: '请输入姓名', required: true, value: '张三' }],
     * });
     * toast('提交成功');
     * ```
     */
    submitLuckyLotteryReceive(options: LuckyLotterySubmitReceiveOptions): Promise<unknown>;
}

declare interface LuckyLotteryActivityDetailData {
    /** 活动 ID */
    taskId: number;
    /** 活动模板 */
    lotteryStyle: string;
    /** 活动名称 */
    activityName: string;
    /** 活动开始时间，单位：毫秒 */
    startTime: number;
    /** 活动结束时间，单位：毫秒 */
    endTime: number;
    /** 抽奖频率 */
    drawFrequency: string;
    /** 抽奖次数 */
    drawTimes: number;
    /** 中奖限制 */
    winLimit: string;
    /** 最大中奖人数 */
    maxWins: number;
    /** 是否显示中奖名单 */
    showWinners: boolean;
    /** 活动规则 */
    rules: string;
    /** 未中奖设置 */
    noWinSetting: LuckyLotteryMissSetting;
    /** 频道 ID 列表 */
    channelIds: Channel[];
    /** 奖品列表 */
    prizes: LuckyLotteryPrize[];
    /** 活动状态 */
    status: string;
    /** 是否到达最大抽奖次数 */
    reachMaxDrawTimes: boolean;
    /** 是否到达最大中奖次数 */
    reachMaxWinTimes: boolean;
}

declare interface LuckyLotteryActivityItem {
    /** 活动 ID */
    taskId: number;
    /** 活动结束时间，单位：毫秒 */
    endTime: number;
    /** 奖品列表 */
    prizes: LuckyLotteryPrize[];
    /** 活动名称 */
    activityName: string;
}

declare enum LuckyLotteryEvent {
    /** 有抽奖活动 */
    OnLuckyLottery = "onLuckyLottery",
    /** 没有抽奖活动 */
    OffLuckyLottery = "offLuckyLottery",
    /** 开始抽奖 */
    StartLuckyLottery = "startLuckyLottery",
    /** 抽奖结束 */
    StopLuckyLottery = "stopLuckyLottery"
}

declare type LuckyLotteryEventRelations = {
    [LuckyLotteryEvent.OnLuckyLottery]: null;
    [LuckyLotteryEvent.StartLuckyLottery]: {
        activityId: number;
    };
    [LuckyLotteryEvent.StopLuckyLottery]: {
        activityId: number;
    };
    [LuckyLotteryEvent.OffLuckyLottery]: null;
};

declare interface LuckyLotteryMissSetting {
    /** 未中奖名称 */
    name: string;
    /** 未中奖占位图片 */
    image: string;
}

declare interface LuckyLotteryPrize {
    /** 奖品名称 */
    prizeName: string;
    /** 奖品类型 */
    prizeType: PrizeType;
    /** 奖品数量约束 */
    prizeQuantityType: string;
    /** 中奖概率 */
    winningProbability: number;
    /** 奖品分数 */
    prizeScore?: number;
    /** 奖品图片 */
    prizeImage: string;
    /** 奖品收集信息 */
    collectItems: CollectItem[];
    /** 奖品 ID */
    id: number;
    /** 奖品位置 */
    position: number;
    /** 奖品 ID */
    prizeId: number;
    /** 奖品剩余库存 */
    currentCount: number;
}

declare interface LuckyLotteryPrizeItem {
    /** 记录 ID，唯一标识 */
    recordId: number;
    /** 奖品 ID */
    prizeId: number;
    /** 奖品名称 */
    prizeName: string;
    /** 创建时间，单位：毫秒 */
    createTime: number;
    /** 是否已领取 */
    received: boolean;
    /** 奖品类型 */
    prizeType: PrizeType;
    /** 外部积分发放是否成功 */
    externalPointDelivered: boolean;
}

declare interface LuckyLotteryReceiveData {
    /** 领取方式 */
    receiveType: PrizeAcceptType_2;
    /** 是否已领取 */
    isReceived: boolean;
    /** 表单列表 */
    formList: LuckyLotteryReceiveFormItem[];
    /** 奖品行 ID */
    recordId: number;
    /** 活动 ID */
    taskId: number;
}

/**
 * 领取信息表单节点
 */
declare interface LuckyLotteryReceiveFormItem {
    /** 标题 */
    field: string;
    /** 表单类型 */
    formType: RewardReceiveFormType;
    /** 提示 */
    tips: string;
    /** 是否必填 */
    required: boolean;
    /** 填写的值 */
    value: string | null;
}

declare interface LuckyLotteryReceiveItem {
    /** 标题 */
    field: string;
    /** 提示 */
    tips: string;
    /** 是否必填 */
    required: boolean;
    /** 填写类型 */
    type: RewardReceiveFormType;
    /** 填写值 */
    collectValue: string;
}

declare interface LuckyLotteryResult {
    /** 中奖奖品 */
    prize: LuckyLotteryResultPrizeItem;
    /** 参与人数 */
    participateUserCount: number;
    /** 中奖人数 */
    winnersCount: number;
    /** 库存不足的奖品 ID */
    notEnoughPrizeId: number;
}

declare interface LuckyLotteryResultPrizeItem {
    /** 记录 ID，唯一标识 */
    recordId: number;
    /** 奖品 ID */
    prizeId: number;
    /** 奖品名称 */
    prizeName: string;
    /** 奖品类型 */
    prizeType: PrizeType;
    /** 奖品分数 */
    prizeScore: number;
    /** 奖品图片 URL */
    prizeImage: string;
    /** 奖品数量类型 */
    prizeQuantityType: string;
    /** 奖品数量 */
    prizeQuantity: number;
    /** 中奖概率 */
    winningProbability: number;
    /** 中奖时间 */
    drawTime: number;
}

declare enum LuckyLotterySocketEvent {
    StartTask = "START_TASK",
    EndTask = "END_TASK"
}

declare interface LuckyLotterySubmitReceiveItem {
    /** 标题 */
    field: string;
    /** 填写类型 */
    type: RewardReceiveFormType;
    /** 提示 */
    tips: string;
    /** 是否必填 */
    required: boolean;
    /** 填写值 */
    collectValue: string;
}

declare interface LuckyLotterySubmitReceiveOptions {
    /** 活动 ID */
    taskId: number;
    /** 奖品行 ID */
    recordId: number;
    /** 领取信息 */
    collectItems: LuckyLotterySubmitReceiveItem[];
}

declare enum LuckyLotteryTemplate {
    /** 九宫格 */
    Grid = "grid",
    /** 大转盘 */
    Wheel = "wheel"
}

declare interface LuckyLotteryWinnersItem {
    /** 用户昵称 */
    nick: string;
    /** 奖品名称 */
    prizeName: string;
}

/**
 * 主屏的内容
 */
export declare enum MainScreenContent {
    /** 播放器 */
    Player = "player",
    /** 文档 */
    Doc = "doc"
}

/**
 * 观看页三分屏主屏幕布局类型
 */
export declare enum MainScreenLayoutMode {
    /** 以文档为主 */
    Ppt = "ppt",
    /** 以视频为主 */
    Video = "video",
    /** 跟随讲师 */
    FollowTeacher = "followTeacher",
    /** 仅视频 */
    OnlyVideo = "only-video"
}

declare interface MarqueeData$1 {
    alpha: string;
    setting: number;
    fontColor: string;
    filterColor: string;
    fontSize: number;
    show: 'on' | 'off';
    filter: 'on' | 'off';
    username: string;
    [propName: string]: string | number | undefined;
}

/**
 * 播放器回调的跑马灯数据
 */
export declare interface MarqueeData {
    /**
     * 透明度，100% 为完全透明
     */
    alpha: string | number;
    /**
     * 跑马灯模式
     */
    setting: number;
    /**
     * 字体颜色
     */
    fontColor: string;
    /**
     * 字体大小
     */
    fontSize: number;
    /**
     * 阴影颜色
     */
    filterColor: string;
    /**
     * 是否显示字体阴影
     */
    filter: 'on' | 'off';
    /**
     * 跑马灯内容
     */
    username: string;
    /** 是否展示跑马灯 */
    show: 'on' | 'off';
}

/**
 * 跑马灯模块事件
 * @eventenum {@link MarqueeEventsRelations}
 */
export declare enum MarqueeEvents {
    /**
     * 跑马灯数据更新
     * @internal
     * @ignore
     */
    MarqueeDataUpdate = "MarqueeDataUpdate",
    /**
     * 跑马灯检查异常
     * @version v0.4.0
     * @internal
     * @ignore
     */
    MarqueeCheckError = "MarqueeCheckError"
}

/**
 * 跑马灯模块事件回调参数配置
 */
export declare type MarqueeEventsRelations = {
    [MarqueeEvents.MarqueeDataUpdate]: {
        /**
         * 跑马灯数据
         */
        marqueeData: MarqueeData;
    };
    [MarqueeEvents.MarqueeCheckError]: {
        /**
         * 错误码
         * @version v2.3.0
         */
        code: string;
    };
};

/**
 * 跑马灯设置信息
 */
export declare interface MarqueeSetting {
    /**
     * 跑马灯类型
     */
    marqueeType: MarqueeType;
    /**
     * 跑马灯内容，跑马灯类型为 {@link MarqueeType.Nickname} 时返回当前用户昵称
     */
    marqueeContent: string;
}

/**
 * 跑马灯实例对象
 */
export declare interface MarqueeTarget {
    /**
     * 跑马灯标识
     */
    id: string;
    /**
     * 跑马灯实例
     * @internal
     * @inheritdoc
     */
    marqueeInstance: PlayerMarquee;
    /**
     * 设置跑马灯内容
     */
    setContent: (content: string) => void;
    /**
     * 销毁当前对象
     */
    destroyTarget: () => void;
}

/**
 * 跑马灯类型
 */
export declare enum MarqueeType {
    /**
     * 固定值
     */
    Fixed = "fixed",
    /**
     * 登录用户名
     */
    Nickname = "nickname",
    /**
     * 自定义 URL
     */
    DiyUrl = "diyurl"
}

export declare type MaybePromise<R> = () => Promise<R> | R;

declare type MaybePromise_2<R> = () => Promise<R> | R;

declare type MaybePromise_3<R> = () => Promise<R> | R;

declare interface MaybeSocket {
    /** socket 的链接查询参数 */
    query?: Record<string, string>;
    /** 发送事件 */
    emit: (event: string, ...args: any[]) => void;
    /** 监听事件 */
    on: (event: string, fn: (...args: any[]) => unknown) => void;
}

/** 频道事件 */
export declare enum MenuEvents {
    /** 频道菜单改变 */
    ChannelMenuChange = "ChannelMenuChange"
}

export declare type MenuEventsRelations = {
    [MenuEvents.ChannelMenuChange]: {
        channelMenus: ChannelMenuItem[];
        type: LanguageType;
    };
};

/** iframe postMessage 事件类型 */
export declare enum MicroActivityIframeEventType {
    /** 跳转的互动功能不支持 PC 端访问，仅支持移动端访问 */
    HXC_ONLY_MOBILE = "HXC_ONLY_MOBILE",
    /** 互动功能页回到首页, 即将废弃 */
    HXC_BACK_HOME = "HXC_BACK_HOME",
    /** 特殊互动功能需要全屏展示，即将废弃，默认都是全屏展示 */
    HXC_FULL_SCREEN = "HXC_FULL_SCREEN",
    /** 强制全屏钩子，目前应该仅用于 “Hi现场” 中 “签名墙” 功能 */
    HXC_FORCE_FULL_SCREEN = "HXC_FORCE_FULL_SCREEN",
    /** 恢复页面默认状态 */
    HXC_RESTORE_DEFAULT = "HXC_RESTORE_DEFAULT",
    /** 禁止页面滚动 */
    HXC_DISABLE_PAGE_SCROLL = "HXC_DISABLE_PAGE_SCROLL",
    /** 请求设备权限，目前用于 “Hi现场” 中 “摇一摇” 功能获取陀螺仪权限 */
    HXC_REQUEST_DEVICE_PERMISSION = "HXC_REQUEST_DEVICE_PERMISSION",
    /** 传递设备信息 */
    PLV_DEVICEMOTION_SWITCH = "PLV_DEVICEMOTION_SWITCH"
}

/**
 * 微活动设置
 */
export declare interface MicroActivitySetting {
    /** 微活动开关 */
    microActivityEnabled: boolean;
    /** 挂件图标地址 */
    pendantIcon: string;
}

/**
 * 连麦状态
 */
export declare interface MicroPhoneStatusData {
    type: ConnectMicType;
    state: 'open' | 'close';
}

declare interface MicStreamInfo {
    /** 流 id */
    streamId: string;
    /** 昵称 */
    nick: string;
    /** 头像 */
    pic: string;
    /** 用户身份 */
    userType: ChatUserType;
}

declare type MicStreamInstance = LocalStreamInstance | UserStreamInstance;

/** 混合流渲染模式 */
export declare enum MixStreamRenderMode {
    /** 剪裁模式 */
    Cover = "0",
    /** 填黑模式 */
    Contain = "2"
}

/**
 * 频道引导页布局
 */
export declare enum MobileSplashLayout {
    /** 普通 */
    Normal = "normal",
    /** 大图 */
    Large = "large"
}

/**
 * 移动端观看页布局
 */
export declare enum MobileWatchLayout {
    /** 常规横屏 */
    Normal = "normal",
    /** 带货直播 */
    Portrait = "portrait"
}

/**
 * 模块基础类
 * @internal
 * @ignore
 */
declare class ModuleBase {
    private __watchCore;
    constructor(__watchCore: PolyvWatchCore);
    /**
     * 获取观看核心模块
     * @internal
     * @ignore
     * */
    getWatchCore(): PolyvWatchCore;
    /**
     * 根据传入的应用配置更新模块的配置
     * @internal
     * @ignore
     * */
    updateAppConfig(appConfig: Partial<AppConfig>): void;
    /**
     * 模块安装钩子
     * @internal
     * @ignore
     * */
    setup(): void;
    /**
     * socket 事件绑定钩子
     * @internal
     * @ignore
     * */
    bindSocketEvents(): void;
    /**
     * 销毁钩子
     * @internal
     * @ignore
     * */
    destroy(): void;
}

/**
 * 模块基础类
 * @internal
 * @ignore
 */
declare class ModuleBase_2 {
    private __aiCore;
    constructor(__aiCore: PolyvWatchAICore);
    /**
     * 获取观看核心模块
     * @internal
     * @ignore
     * */
    getAICore(): PolyvWatchAICore;
    /**
     * 根据传入的应用配置更新模块的配置
     * @internal
     * @ignore
     * */
    updateAppConfig(appConfig: Partial<AICoreConfig>): void;
    /**
     * 模块安装钩子
     * @internal
     * @ignore
     * */
    setup(): void;
    /**
     * socket 事件绑定钩子
     * @internal
     * @ignore
     * */
    bindSocketEvents(): void;
    /**
     * 销毁钩子
     * @internal
     * @ignore
     * */
    destroy(): void;
}

/**
 * 模块基础类
 * @internal
 * @ignore
 */
declare class ModuleBase_3 {
    private __identifyCore;
    constructor(__identifyCore: IdentifyCore);
    /**
     * 获取观看核心模块
     * @internal
     * @ignore
     * */
    getIdentifyCore(): IdentifyCore;
    /**
     * 模块安装钩子
     * @internal
     * @ignore
     * */
    setup(): void;
    /**
     * 销毁钩子
     * @internal
     * @ignore
     * */
    destroy(): void;
}

/** 课堂激励点赞数据 */
export declare interface MotivationLikeItem {
    /** 激励次数 */
    times: number;
    /** 激励者Id */
    motivatorId: string;
    /** 激励者昵称 */
    motivatorNick: string;
    /** 激励者角色 */
    motivatorRole: string;
    /** 被激励者Id */
    motivatedId: string;
    /** 被激励者昵称 */
    motivatedNick: string;
    /** 激励点赞类型来源 */
    type: MotivationLikeType;
}

/** 激励类型来源 */
export declare enum MotivationLikeType {
    /** 消息发言 */
    Speak = "speak",
    /** 连麦 */
    Mic = "mic"
}

/**
 * 分会场节点信息
 */
export declare interface MultiMeetingItem {
    /** 频道号 */
    channelId: string;
    /** 频道名称 */
    channelName: string;
    /** 分会场名称 */
    multiMeetingName: string;
    /** 引导页封面图 */
    splashImg: string;
    /** 直播状态 */
    liveStatus: LiveStatus;
    /** 页面浏览次数 */
    pageView: number;
    /** 开始时间 */
    startTime: number | null;
    /** 是否为主会场 */
    isMainChannel: boolean;
    /** 是否为当前频道 */
    isCurrentChannel: boolean;
    /** 观看页地址 */
    watchUrl: string;
}

/** 分会场模板 */
export declare enum MultiMeetingListLayout {
    /** 横向列表 */
    Horizontal = "horizontal",
    /** 竖向列表 */
    Portrait = "portrait"
}

/**
 * 分会场直播状态数据
 */
export declare interface MultiMeetingLiveStatusData {
    channelId: string;
    liveStatus: LiveStatus;
}

/**
 * 分会场设置信息
 */
export declare interface MultiMeetingSetting {
    /** 分会场开关 */
    multiMeetingEnabled: boolean;
    /** 分会场入口名称 */
    multiMeetingEntranceName: string;
    /** 分会场最大数量限制 */
    multiMeetingMaxCount: number;
    /** 主会场频道号 */
    mainChannelId: string | undefined;
    /** 当前频道是否为分会场 */
    isSubChannel: boolean;
    /** 分会场列表模板 */
    multiMeetingListLayout: MultiMeetingListLayout;
    /** 当前处于分会场，是否需要跳转到主会场进行观看授权 */
    needRedirectChannelAuth: boolean;
    /** 跳转授权频道的频道号 */
    redirectAuthChannelId: string | undefined;
}

/**
 * 网络状态枚举
 */
export declare enum NetworkStatus {
    /** 未知 */
    Unknown = "unknow",
    /** 好 */
    Good = "good",
    /** 普通 */
    Ordinary = "ordinary",
    /** 极差 */
    Bad = "bad"
}

/**
 * 无条件抽奖条件
 */
declare interface NoneCondition extends LotteryConditionBase<LotteryCondition.None> {
}

declare class NormalApi extends ApiQuery_2<NormalApiOptions> {
    constructor(options: ApiQueryConfig_2);
    /** 响应处理器 */
    private __normalAfterResponse;
}

declare interface NormalApiOptions extends ApiOptions_2 {
    /** 是否标准的接口，默认：true */
    isStandard?: boolean;
}

export { NormalProductData }

/**
 * 将数字转换为大写英文字母
 * @param num 数字
 * @returns 字母
 */
declare function numberToLetters(num: number): string;

export declare type OmitAppConfig = Omit<AppConfig, 'env' | 'sdkIntegration' | 'uniqueId' | 'getExtBusinessInfo'>;

declare type OmitAppConfig_2 = Omit<AICoreConfig, 'sourceConfig' | 'autoSetup'>;

declare type OmitAppConfig_3 = Omit<IdentifyCoreConfig, 'sourceConfig'>;

/**
 * 在线时长任务更新类型
 */
export declare enum OnlineTaskUpdateType {
    /** 通过 socket 更新 */
    Socket = "socket",
    /** 通过播放器事件更新 */
    Player = "player"
}

export declare interface OnSpeakCancelTopType {
    EVENT: 'CANCEL_TOP';
    id: string;
}

export declare interface OnSpeakTopSocketType extends SliceIdSpeakTop {
    EVENT: 'TO_TOP';
}

/**
 * 选项统计
 */
declare interface OptionStatistics {
    /** 选项回答人数 */
    answerCount: number;
    /** 选项回答比例 */
    answerPercent: number;
}

/**
 * 订单支付参数
 */
export declare interface OrderPayParams {
    /** 订单号 */
    orderNo: string;
    /** 支付方式 */
    payProvider: PayProvider;
}

export declare type OriginLanguageType = `${WatchSdkLangEnum}`;

/**
 * 下一场直播预约配置
 */
export declare type OtherChannelBookingConfig = OtherChannelBookingConfigItem[];

/**
 * 下一场直播预约配置
 */
export declare interface OtherChannelBookingConfigItem extends LiveBookingConfig {
    /** 频道 id */
    channelId: string;
    /** 频道名称 */
    channelName: string;
    /** 频道开始时间 */
    startTime: string;
}

/**
 * 频道自定义预约信息
 */
export declare type OtherChannelCustomBooking = OtherChannelCustomBookingItem[];

/**
 * 频道自定义预约信息（单个）
 */
export declare interface OtherChannelCustomBookingItem extends SmsBooking {
    /** 频道 id */
    channelId: string;
    /** 频道 名称 */
    channelName: string;
}

/**
 * 频道短信预约信息
 */
export declare type OtherChannelSmsBooking = OtherChannelSmsBookingItem[];

/**
 * 下一场直播短信预约信息
 */
export declare interface OtherChannelSmsBookingItem extends SmsBooking {
    /** 频道 id */
    channelId: string;
}

/**
 * 频道微信预约信息
 */
export declare type OtherChannelWxBooking = OtherChannelWxBookingItem[];

export declare interface OtherChannelWxBookingItem extends WxBooking {
    /** 频道 id */
    channelId: string;
    /** 频道名称 */
    channelName: string;
    /** 频道开始时间 */
    startTime: string;
}

export declare interface OutLineItem {
    /** 文件Id */
    fileId: string;
    /** 回放大纲数据 json 地址 */
    outlineUrl: string;
    /** 回放大纲 生成状态 */
    status: OutLineStatus;
    /** 互动答题数据 json 地址 */
    questionUrl: string | null;
}

export declare enum OutLineStatus {
    /** 初始化 */
    Init = "init",
    /** 生成失败 */
    Fail = "fail",
    /** 字幕生成中 */
    Srt_Processing = "srt_processing",
    /** 大纲生成中 */
    Outline_Processing = "outline_processing",
    /** 完成 */
    Success = "success"
}

/**
 * 奖励发放失败原因
 */
export declare enum OutTradeErrorCode {
    /**
     * 企业营销账户异常
     */
    WxPayAccountError = "WX_PAY_ERROR",
    /**
     * 未在微信内参与活动
     */
    NotWechatUser = "NOT_WECHAT_USER",
    /**
     * 系统异常
     */
    SystemError = "SYSTEM_ERROR",
    /**
     * 未绑定邀请员，无法获得红包
     */
    MarketingAccountUnbound = "MARKETING_ACCOUNT_UNBOUND",
    /**
     * 邀请员营销钱包异常
     */
    MarketingAccountError = "MARKETING_ACCOUNT_ERROR"
}

/** 页面广告跳转地址 */
export declare type PageAdvertHrefSetting = Record<`pageAdvertHref${number}`, string>;

/**
 * @file 频道广告类型
 */

/** 页面广告（图片） */
export declare type PageAdvertImageSetting = Record<`pageAdvertImg${number}`, string>;

/**
 * 页面广告信息
 */
export declare interface PageAdvertItem {
    /** 广告内容 */
    content: string;
    /** 广告类型 */
    advertType: PageAdvertType;
    /** 跳转地址 */
    href?: string;
    /** 跳转方式 */
    jumpWay: LinkJumpWay;
    /** 跳转链接 */
    link?: string;
    /** 移动端跳转链接 */
    mobileLink?: string;
    /** 移动端app跳转链接 */
    mobileAppLink?: string;
    /** 移动端 app 跳转方式 */
    mobileAppLinkJumpWay: LinkJumpWay;
    /** PC端跳转链接 */
    pcLink?: string;
    /** PC端跳转方式 */
    pcLinkJumpWay: LinkJumpWay;
    /** 微信小程序应用id */
    wxMiniprogramAppId?: string;
    /** 微信小程序内页面路径及参数 */
    wxMiniprogramLink?: string;
    /** 微信小程序原始id */
    wxMiniprogramOriginalId?: string;
    /** iOS 跳转链接 */
    iosLink?: string;
    /** Android 跳转链接 */
    androidLink?: string;
    /** harmony 跳转链接 */
    harmonyLink?: string;
    /** 跳转类型 */
    hrefType?: string;
}

export declare interface PageAdvertListItem {
    /** 图片地址 */
    image: string;
    /** 文字 */
    text: string;
    /** 链接 */
    link: string;
    /** 跳转链接类型 */
    hrefType: string;
    /** 跳转方式 */
    jumpWay: LinkJumpWay;
    /** 移动端跳转链接 */
    mobileLink: string;
    /** 移动端app跳转链接 */
    mobileAppLink: string;
    /** 移动端 app 跳转方式 */
    mobileAppLinkJumpWay: LinkJumpWay;
    /** PC端跳转链接 */
    pcLink: string;
    /** PC端跳转方式 */
    pcLinkJumpWay: LinkJumpWay;
    /** 微信小程序appId */
    wxMiniprogramAppId: string;
    /** 微信小程序链接 */
    wxMiniprogramLink: string;
    /** 微信小程序原始id */
    wxMiniprogramOriginalId: string;
    /** iOS 跳转链接 */
    iosLink: string;
    /** Android 跳转链接 */
    androidLink: string;
    /** harmony 跳转链接 */
    harmonyLink: string;
}

/** 页面广告（文字） */
export declare type PageAdvertTextSetting = Record<`pageAdvertText${number}`, string>;

/**
 * 页面广告类型
 */
export declare enum PageAdvertType {
    /** 文字广告 */
    Text = "text",
    /** 图片广告 */
    Image = "image"
}

/**
 * 分页数据
 */
export declare interface PageContent<I = unknown> {
    /** 当前页数 */
    pageNumber: number;
    /** 每页数量 */
    pageSize: number;
    /** 总记录数 */
    totalItems: number;
    /** 总页数 */
    totalPages: number;
    /** 内容列表 */
    contents: I[];
}

/**
 * 分页数据
 */
declare interface PageContent_2<I = unknown> {
    /** 当前页数 */
    pageNumber: number;
    /** 每页数量 */
    pageSize: number;
    /** 总记录数 */
    totalItems: number;
    /** 总页数 */
    totalPages: number;
    /** 内容列表 */
    contents: I[];
}

/**
 * 分页入参
 */
declare interface PageOptions {
    /** 页数 */
    pageNumber?: number;
    /** 页码 */
    pageSize?: number;
}

/**
 * 页面浏览次数设置
 */
export declare interface PageViewSetting {
    /** 页面浏览次数开关 */
    pvShowEnabled: boolean;
    /** 页面浏览次数 */
    pageViewCount: number;
    /** 移动端页面浏览次数位置 */
    mobilePvShowLocation: PageViewShowLocation;
}

/**
 * 页面浏览次数显示位置
 */
export declare enum PageViewShowLocation {
    /** 播放器 */
    Player = "player",
    /** 频道介绍 */
    Desc = "desc"
}

/**
 * 转换选项
 */
export declare interface ParseOptions {
    /**
     * 是否转换链接
     * @default false
     */
    parseLink?: boolean;
    /**
     * 移除表情内容
     * @default false
     */
    removeEmotion?: boolean;
    /**
     * 是否转换表情
     * @default false
     */
    parseEmotion?: boolean;
    /**
     * 是否转换换行符
     * @default false
     */
    parseLineBreak?: boolean;
}

export declare interface ParseProductDetail extends ProductGoodData {
    materialId: string;
    /** 是否开价 */
    openPriceEnable?: string;
}

/**
 * 打赏支付数据
 */
export declare interface PayDonateData {
    /** 打赏类型 */
    donateType: DonateType;
    /** 是否为免费礼物 */
    isFree: boolean;
    /** 支付记录 id */
    logId?: string;
    /**
     * 打赏道具 id
     * @version v0.11.0
     * */
    goodId?: string;
    /**
     * 打赏数量
     * @version v0.11.0
     * */
    goodCount: number;
    /**
     * 现金打赏时的打赏金额
     * @version v0.11.0
     * */
    amount?: string | number;
    /** 支付地址 */
    codeUrl?: string;
    /** 支付二维码地址，付费礼物才存在 */
    qrCodeUrl?: string;
    /** 微信支付签名数据 */
    wxPaySignData?: WxPaySignData;
}

/**
 * 支付打赏参数
 */
export declare interface PayDonateParams {
    /**
     * 打赏类型
     */
    donateType: DonateType;
    /**
     * 道具打赏道具 id
     */
    goodId?: string;
    /**
     * 打赏数量
     */
    goodCount?: number;
    /**
     * 现金打赏时的打赏金额，单位：元
     */
    amount?: string | number;
}

/**
 * 支付打赏积分参数
 */
export declare interface PayDonatePointParams {
    /** 道具打赏道具 id */
    goodId: string;
    /** 打赏数量 */
    goodCount: number;
}

/**
 * 支付打赏接口响应数据类型
 */
export declare interface PayDonateResponseData {
    /** 支付记录 id */
    logId: string;
    /** 打赏类型 */
    donateType: DonateType;
    /** 是否为免费礼物 */
    freeDonate?: 'true';
    /** 支付二维码地址，如果是付费礼物则存在 */
    codeUrl?: string;
    appId?: string;
    nonceStr?: string;
    package?: string;
    paySign?: string;
    signType?: string;
    timeStamp?: string;
}

/**
 * 支付方式
 */
export declare enum PayProvider {
    /** 微信 */
    Wechat = "WECHAT",
    /** 支付宝 */
    Alipay = "ALIPAY"
}

/**
 * 订单状态 待支付|已支付|免费
 */
export declare type PayStatus = 'wait_pay' | 'payed' | 'free';

export declare type PickAuthSettingItem<T extends AuthType> = AuthSettingItemMaps[T];

/** 根据来源获取聊天消息类型 */
export declare type PickChatMsgType<S extends ChatMsgSource> = ChatMsgTypeMap[S];

/** 获取泛域名支付参数 */
export declare type PickWatchDomainPayParams<T extends WatchDomainPayType> = WatchDomainPayParamsRelation[T];

/**
 * 回放模块事件
 * @version v0.9.0
 */
export declare enum PlaybackEvents {
    /**
     * 当前回放对象已更新
     */
    CurrentPlaybackTargetUpdated = "CurrentPlaybackTargetUpdated"
}

/**
 * 回放模块事件回调参数配置
 * @version v0.9.0
 */
export declare type PlaybackEventsRelations = {
    [PlaybackEvents.CurrentPlaybackTargetUpdated]: {
        target: PlaybackTarget | undefined;
    };
};

/**
 * 回放方式
 */
export declare enum PlaybackMode {
    /** 单个回放 */
    Single = "single",
    /** 列表回放 */
    List = "list"
}

declare interface playbackMultipleSubtitleOptions {
    isOriginal?: YN;
    srtUrl?: string;
    name?: string | null;
    checked: boolean;
    language?: string;
    id?: number;
    text?: string | null;
    source?: string;
    optionList?: ReplaySubtitleItem[];
}

/**
 * 回放来源
 * @desc 目前兼容对外导出类型使用
 * @deprecated v2.14.0 起废弃，请使用 PlaybackType 代替
 */
export declare type PlaybackOrigin = PlaybackType;

export declare interface PlaybackOutlineContentItem {
    /** 大纲标题 */
    title: string;
    /** 大纲 开始播放seek */
    startTime: string;
    /** 大纲 结束播放seek */
    endTime: string;
    /** 开始索引 */
    startIndex: number;
    /** 结束索引 */
    endIndex: string;
    /** 段落总结列表 */
    summary: string[];
    /** 关键词 列表 */
    keyword: string[];
}

export declare interface PlaybackOutlineData {
    /**
     * 摘要内容
     */
    introduction: string;
    /**
     * 分段总结
     */
    outlineContent: PlaybackOutlineContentItem[];
}

declare interface PlaybackOutlineOptions {
    /** 回放 id */
    id: string;
    /** 回放类型 */
    type: string;
}

/**
 * 回放的页面模式
 */
export declare enum PlaybackPageMode {
    /** 视频模式 */
    Video = 0,
    /** 音频模式 */
    Audio = 1
}

export declare interface PlaybackQuestionData {
    /**
     * 问题列表
     */
    questions: PlaybackQuestionItem[];
}

declare interface PlaybackQuestionItem {
    /**
     * 问题 id
     */
    questionId: string;
    /**
     * 问题题目
     */
    question: string;
    /**
     * 问题类型
     */
    type: 'single' | 'multiple';
    /**
     * 问题答案
     */
    answer: string;
    /**
     * 问题选项
     */
    selectOptions: PlaybackQuestionOption[];
    /**
     * 弹题时间，单位：秒
     */
    questionTriggerTime: number;
    /**
     * 溯源时间，单位：秒
     */
    videoReviewTime: number;
}

declare interface PlaybackQuestionOption {
    /**
     * 选项 id
     */
    option: string;
    /**
     * 选项内容
     */
    content: string;
}

/**
 * 暂存文件对象
 */
export declare interface PlaybackRecordFile extends PlaybackVideoBasic {
    /** 文件 id */
    fileId: string;
    /** m3u8 文件 */
    m3u8: string | null;
    /** mp4 文件 */
    mp4: string | null;
}

/**
 * 回放对象
 */
export declare interface PlaybackTarget {
    /**
     * 回放唯一标识
     * @tip 暂存时为 fileId，回放、点播时为 vid
     */
    playbackId: string;
    /** 回放标题 */
    title: string;
    /** 开始时间 */
    startTime?: number;
    /** 回放时长 */
    duration: number;
    /** 首帧图片 */
    firstImage?: string;
    /** 宽度 */
    width?: number;
    /** 高度 */
    height?: number;
    /**
     * 回放时是否能连接聊天室
     * @desc 默认 true
     * @version v2.14.0
     */
    chatConnectEnabled: boolean;
    /**
     * 是否能够聊天重放
     * @desc 从 v2.0.0 开始，将聊天重放功能细化成了聊天消息、卡片推送等聊天功能重放，但在这之前的版本， chatReplayEnabled 和 chatMsgReplayEnabled 等效
     */
    chatReplayEnabled: boolean;
    /**
     * 是否能够进行聊天消息重放
     * @version v2.0.0
     */
    chatMsgReplayEnabled: boolean;
    /**
     * 是否能够进行卡片推送重放
     * @version v2.0.0
     */
    cardPushReplayEnabled: boolean;
    /**
     * 是否能够进行签到重放
     * @version v2.1.0
     */
    checkInReplayEnabled: boolean;
    /**
     * 是否能够进行答题卡重放
     * @version v2.1.0
     */
    answerCardReplayEnabled: boolean;
    /**
     * 是否能够进行问卷重放
     * @version v2.1.0
     */
    questionnaireReplayEnabled: boolean;
    /**
     * 是否能够商品库重放
     * @version v0.9.0
     * */
    productReplayEnabled: boolean;
    /** 回放选项 */
    playbackOptions: SetupPlayerPlaybackOptions;
    /**
     * 回放视频字幕列表
     * @version v0.9.0
     * */
    subtitleList: ReplaySubtitleItem[];
    /**
     * 音频地址
     * @version v1.7.0
     */
    audio: string;
    /**
     * 互动答题开关
     * @version v2.3.0
     */
    aiKnowledgeQuizEnabled: boolean;
    /**
     * AI 回放大纲
     */
    outline?: OutLineItem;
}

/**
 * 回放类型
 */
export declare enum PlaybackType {
    /** 暂存 */
    Record = "record",
    /** 回放 */
    Playback = "playback",
    /** 点播 */
    Vod = "vod",
    /** 素材库视频 */
    Material = "material"
}

export declare interface PlaybackVideoBasic {
    /** 标题 */
    title: string;
    /** 来源 */
    origin: PlaybackVideoOrigin;
    /** 场次号 */
    channelSessionId: string | null;
    /** 裁减的原始场次号 */
    originSessionId: string | null;
    /** 视频时长，格式：h:m:s */
    duration: string;
    /** 开始时间，格式：20220216153445 */
    startTime: string;
    /** 宽度 */
    width: number;
    /** 高度 */
    height: number;
    /** 页面模式 */
    pageMode: PlaybackPageMode;
    /** 音频地址 */
    audio: string | null;
    /** 回放视频字幕列表 */
    subtitleList: ReplaySubtitleItem[] | null;
    /** AI 回放大纲 */
    outline?: OutLineItem;
    /** 转存到直播的视频 id */
    videoId: string | null;
    /** 转存到点播的视频 id */
    videoPoolId: string | null;
    /** 是否需要点播加密，1 为需要加密 */
    seed: 0 | 1;
}

/**
 * 回放视频来源
 */
export declare enum PlaybackVideoOrigin {
    /** CDN 自动录制 */
    Auto = "auto",
    /** 裁减 */
    Clip = "clip",
    /** 合并录制 */
    Merge = "merge",
    /** 合并 */
    Combine = "combine",
    /** 手动录制 */
    Manual = "manual",
    /** 研讨会自动录制 */
    SeminarAuto = "seminar-auto",
    /** 研讨会手动录制 */
    SeminarManual = "seminar-manual",
    /** 阿里云裁减 */
    AliyunClip = "aliyunClip",
    /** 智能剪辑 */
    SmartClip = "smart-clip",
    /** AI 裁剪 */
    AiClip = "ai-clip",
    /** 点播 */
    Vod = "vod",
    /** 素材库视频 */
    Material = "material"
}

export declare interface PlaybackVideoSource {
    mp4: string | null;
    m3u8: string | null;
    enFileUrl?: string;
}

/**
 * 回放目标对象
 */
export declare interface PlaybackVideoTarget extends PlaybackVideoBasic {
    /** 录制文件 id */
    fileId: string;
    /** 回放文件地址 */
    fileUrl: string;
    /** 首帧图，非完整地址 */
    firstImage: string;
    /** 点播回放地址 */
    url?: string;
    /** 英文视频回放地址 */
    enFileUrl?: string;
}

/**
 * 通过 vid 观看回放的基础信息
 */
export declare interface PlaybackWatchBasicInfo {
    /** 回放 vid */
    vid?: string;
    /** 回放视频地址 */
    vodUrl?: string;
    /** 回放视频名称 */
    videoName?: string;
}

export declare enum PlayerCdnType {
    Tx = "tx",
    Ali = "ali"
}

export declare interface PlayerChannelJsonData {
    /** 线路列表 */
    lines: PlayerLineData[];
    /** 暖场图片 */
    coverImage: string;
    /** 暖场图片跳转地址 */
    coverHref: string;
    /** 暖场视频的标识 */
    waitImage: string;
    /** H5低延迟 FLV 观看 */
    h5LowLatencyFlvEnabled: YN;
    /** 跑马灯类型 */
    marqueeType: string;
    /** 跑马灯地址 */
    marquee: string | null;
    /** 播放器自动清晰度配置 */
    autoResolutionConfig?: {
        enabled: YN;
        aliPullUrl?: string;
        txPullUrl?: string;
    };
    /** 当前主线路cdn类型 */
    cdnType: PlayerCdnType;
    /** 录制文件音频流地址 */
    recordFileAudioUrl: string | null;
    /** 流截图地址 */
    streamCaptureUrl: string | null;
}

/**
 * 播放器控制器类型
 */
export declare interface PlayerController {
    /** 初始化播放器 */
    setupPlayer(options: SetupPlayerOptions): Promise<void>;
    /** 播放 */
    play(): void;
    /** 冻结播放 */
    freezePlay(isFreeze: boolean): void;
    /** 暂停 */
    pause(): void;
    /** 停止拉流 */
    stop(): void;
    /** 是否支持刷新 */
    getRefreshSupport(): boolean;
    /** 刷新 */
    refresh(): void;
    /** 设置音量（0～1） */
    setVolume(volume: number): void;
    /** 获取当前音量 */
    getCurrentVolume(): number;
    /** 添加弹幕 */
    addBarrage(options: BarrageAddOptions): void;
    /** 设置弹幕显示状态 */
    setBarrageShow(show: boolean): void;
    /** 获取是否支持弹幕速度切换 */
    getBarrageSpeedSupport(): boolean;
    /** 设置弹幕速度 */
    setBarrageSpeed(speed: number): void;
    /** 获取是否支持弹幕字号切换 */
    getBarrageSizeSupport(): boolean;
    /** 设置弹幕字号 */
    setBarrageSize(size: number): void;
    /** 获取是否支持弹幕位置切换 */
    getBarrageLocationSupport(): boolean;
    /** 设置弹幕位置显示方向 */
    setBarrageAreaDirection(direction: IDirection): void;
    /** 设置弹幕位置显示百分比 */
    setBarrageAreaPercentage(percent: number): void;
    /** 获取是否支持弹幕透明度切换 */
    getBarrageAlphaSupport(): boolean;
    /** 设置弹幕透明度 */
    setBarrageAlpha(alpha: number): void;
    /** 更新弹幕显示区域 */
    resizeBarrage(): void;
    /** 切换线路 */
    changeLine(line: number): void;
    /** 获取线路总数 */
    getLineCount(): number;
    /** 获取当前线路 */
    getCurrentLine(): number;
    /** 切换清晰度级别 */
    changeQualityLevel(level: number): void;
    /** 获取可选的清晰度列表 */
    getQualityLevels(): QualityLevelItem[];
    /** 获取当前的清晰度级别 */
    getCurrentQualityLevel(): number;
    /** 获取可选的倍速列表 */
    getRateList(): number[];
    /** 设置倍速 */
    changeRate(rate: number): void;
    /** 获取当前倍速 */
    getCurrentRate(): number;
    /** 获取当前播放时间 */
    getCurrentTime(): number;
    /** 获取播放总时长 */
    getDurationTime(): number;
    /** 设置播放进度 */
    seekVideo(time: number): void;
    /**
     * 判断是否支持直播时移
     * @desc 需要在播放器初始化后才能正常使用
     *  */
    getSupportTimeShift(): boolean;
    /** 切换回放 */
    changePlayback(playbackOptions: SetupPlayerPlaybackOptions): Promise<void>;
    /** 设置跑马灯内容 */
    setMarqueeContent(content: string): void;
    /** 改变播放器皮肤实时字幕开关 */
    changeSubtitleConfig(flag: boolean, checked?: boolean): void;
    /** 销毁播放器 */
    destroyPlayer(): Promise<void>;
    /** 设置播放器回放字幕选项 */
    setPlayerReplaySubtitle(): void;
    /**
     * 判断是否支持系统全屏
     */
    getSupportSystemFullscreen(): boolean;
    updateSubtitleSelectBtnConfig(options: SubtitleSelectBtnConfig): void;
    /** 获取播放器统计信息 */
    getStatisticInfo(): PlayerStatisticsInfoCbParams;
    /** 获取播放器视频信息 */
    getVideoInfo(): PlayerVideoInfo;
    /**
     * 播放器容器变化时，刷新低延迟canvas的渲染
     * @param viewRotate 屏幕旋转角度
     * @param bodyRotate 身体旋转角度
     */
    resizeScreen(viewRotate?: number, bodyRotate?: number): void;
    /**
     * 设置直播流 token
     * @param token
     */
    setLiveStreamToken(token: string): void;
    /**
     * 设置手势 seek 方向
     * @api
     * @param direction 方向
     */
    setGestureDirection(direction: 'vertical' | 'horizontal'): void;
    /**
     * 执行缓冲监测切换线路/清晰度
     * @param info
     */
    switchDetectionByInfo(info: PlayerDetectionSwitchDetail): void;
    /** 获取流截图地址 */
    getStreamCaptureUrl(): string | undefined;
    /**
     * 退出网页全屏
     */
    exitWebPageFullScreen(): void;
    /** 当前播放器是否支持画中画 */
    supportPictureInPicture(): boolean;
    /** 获取画中画状态 */
    getPictureInPictureStatus(): boolean;
    /** 进入画中画 */
    enterPictureInPicture(): Promise<PictureInPictureWindow | void>;
    /** 退出画中画 */
    leavePictureInPicture(): Promise<void>;
    /** 切换画中画 */
    togglePictureInPicture(): void;
}

/**
 * 播放器控制器类
 */
export declare interface PlayerControllerCtor {
    new (_playerModule: PlvPlayerModule): PlayerController;
}

export declare interface PlayerDetectionCbParams {
    /**
     * 播放缓冲监测提示状态
     */
    type: PlayerLoadingDetectionType;
    /**
     * 播放缓冲监测状态详细信息
     */
    detail?: PlayerDetectionSwitchDetail;
}

/**
 * 播放缓冲监测提示信息
 */
export declare interface PlayerDetectionSwitchDetail {
    /**
     * 播放缓冲监测提示建议方案类型
     */
    type: PlayerDetectionSwitchType;
    /**
     * 播放缓冲监测提示信息
     */
    index: number;
}

/**
 * 播放缓冲监测提示建议方案类型
 */
export declare enum PlayerDetectionSwitchType {
    /**
     * 切换线路
     */
    LINE = "line",
    /**
     * 降低码率
     */
    HD = "hd"
}

/**
 * 播放器异常原因
 */
export declare enum PlayerErrorReason {
    /**
     * 未知异常
     */
    Unknown = "Unknown",
    /**
     * 网络异常
     */
    NetworkError = "NetworkError",
    /**
     * restrictjson 校验失败
     */
    RestrictJsonError = "RestrictJsonError",
    /**
     * sdk 加载失败
     */
    SdkLoadError = "SdkLoadError"
}

/**
 * 播放器模块事件
 * @eventenum {@link PlayerEventsRelations}
 */
export declare enum PlayerEvents {
    /**
     * 播放器信息修改事件
     *
     * 播放器模块会保存播放器的状态信息，通过该事件监听播放器状态改变。
     * @example
     * ```js
     * watchCore.player.eventEmitter.on(PlayerEvents.PlayerInfoChange, (data) => {
     *   const playerInfo = data.playerInfo;
     *   console.log('播放状态', playerInfo.playStatus);
     * });
     * ```
     */
    PlayerInfoChange = "PlayerInfoChange",
    /**
     * 播放器暖场信息更新
     *
     * 暖场信息初始化有一定的延迟，开发者可通过该事件监听暖场信息初始化完成并获取暖场信息。
     * @example
     * ```js
     * watchCore.player.eventEmitter.on(PlayerEvents.PlayerWarmUpSettingChange, () => {
     *   const setting = watchCore.player.getPlayerWarmUpSetting();
     *   console.log('暖场类型', setting.warmUpType);
     *   console.log('暖场图片地址', setting.warmUpImg);
     *   console.log('暖场视频地址', setting.warmUpVideo);
     * });
     * ```
     */
    PlayerWarmUpSettingChange = "PlayerWarmUpSettingChange",
    /**
     * 播放器配置信息加载成功
     *
     * @version v1.3.0
     *
     * 开发者可通过该事件监听播放器配置信息加载成功时机, 并在播放开始前修改部分配置
     * @example
     * ```js
     * watchCore.player.eventEmitter.on(PlayerEvents.PlayerConfigLoaded, () => {
     *   console.log('播放配置加载成功');
     * });
     * ```
     */
    PlayerConfigLoaded = "PlayerConfigLoaded",
    /**
     * 播放器初始化完毕
     *
     * 调用播放器模块的 `setupPlayer` 方法创建播放器时，通过 `PlayerInited` 事件监听播放器初始化完成事件，触发该事件后即可调用播放器的 Api。
     * @example
     * ```js
     * // 创建播放器
     * watchCore.player.setupPlayer({
     *   container: 'NodeElement',
     * });
     *
     * watchCore.player.eventEmitter.on(PlayerEvents.PlayerInited, () => {
     *   console.log('播放器初始化完成');
     *   const playerInfo = watchCore.player.getPlayerInfo();
     *   console.log(playerInfo.playerInited); // true
     * });
     * ```
     */
    PlayerInited = "PlayerInited",
    /**
     * 播放器脚本加载完成
     *
     * 调用播放器模块的 `setupPlayer` 方法创建播放器时，在对应播放器脚本加载完成后触发。
     * @version v2.15.0
     */
    PlayerScriptLoaded = "PlayerScriptLoaded",
    /**
     * 播放器播放事件
     *
     * 用户点击播放或通过 Api 播放后会回调播放事件，开发者也可通过 {@link PlayerEvents.PlayerInfoChange} 事件同步播放状态。
     * @example
     * ```js
     * watchCore.player.eventEmitter.on(PlayerEvents.PlayerPlaying, () => {
     *   console.log('播放了');
     * });
     * ```
     */
    PlayerPlaying = "PlayerPlaying",
    /**
     * 播放器暂停事件
     *
     * 用户点击暂停、自动播放失败、通过 Api 暂停都会回调暂停事件，开发者也可通过 {@link PlayerEvents.PlayerInfoChange} 事件同步播放状态。
     * @example
     * ```js
     * watchCore.player.eventEmitter.on(PlayerEvents.PlayerPause, () => {
     *   console.log('暂停了');
     * });
     * ```
     */
    PlayerPause = "PlayerPause",
    /**
     * 音量改变
     *
     * 音量改变时触发该事件。
     * @example
     * ```js
     * watchCore.player.eventEmitter.on(PlayerEvents.VolumeChange, () => {
     *   const currentVolume = watchCore.player.getCurrentVolume();
     *   console.log('当前音量', currentVolume);
     * });
     * ```
     */
    VolumeChange = "VolumeChange",
    /**
     * 线路切换
     *
     * 线路切换时触发该事件。
     * @example
     * ```js
     * watchCore.player.eventEmitter.on(PlayerEvents.LineChange, () => {
     *   const currentLine = watchCore.player.getCurrentLine();
     *   console.log('当前线路', currentLine);
     * });
     * ```
     */
    LineChange = "LineChange",
    /**
     * 清晰度级别切换
     *
     * 清晰度切换时触发该事件。
     * @example
     * ```js
     * watchCore.player.eventEmitter.on(PlayerEvents.QualityLevelChange, () => {
     *   const currentLevel = watchCore.player.getCurrentQualityLevel();
     *   console.log('当前清晰度', currentLevel);
     * });
     * ```
     */
    QualityLevelChange = "QualityLevelChange",
    /**
     * 倍速修改
     *
     * 倍速切换时触发该事件。
     * @example
     * ```js
     * watchCore.player.eventEmitter.on(PlayerEvents.RateChange, () => {
     *   const currentRate = watchCore.player.getCurrentRate();
     *   console.log('当前倍速', currentRate);
     * });
     * ```
     */
    RateChange = "RateChange",
    /**
     * 播放器弹幕改变
     *
     * 播放器弹幕显示状态切换时触发该事件。
     * @example
     * ```js
     * watchCore.player.eventEmitter.on(PlayerEvents.BarrageStatusChange, () => {
     *   const playerInfo = watchCore.player.getPlayerInfo();
     *   console.log('弹幕显示状态', playerInfo.barrageShow);
     * });
     * ```
     */
    BarrageStatusChange = "BarrageStatusChange",
    /**
     * 调起弹幕设置弹窗
     *
     * 移动端下的弹幕设置需要由页面实现，该事件用于监听观众点击播放器的弹幕设置按钮，触发该事件后显示弹幕设置蒙层。
     * @example
     * ```js
     * watchCore.player.eventEmitter.on(PlayerEvents.BarrageSettingClick, () => {
     *   console.log('显示弹幕设置面板');
     * });
     * ```
     */
    BarrageSettingClick = "BarrageSettingClick",
    /**
     * 播放时间改变
     */
    TimeUpdate = "TimeUpdate",
    /**
     * 回放播放结束
     */
    PlaybackOver = "PlaybackOver",
    /**
     * 回放续播事件
     */
    HistoryPlay = "HistoryPlay",
    /**
     * 无延迟播放异常
     *
     * 通过 `LowLatencyError` 事件监听无延迟播放异常，异常后切到正常延迟模式。
     * @example
     * ```js
     * watchCore.player.eventEmitter.on(PlayerEvents.LowLatencyError, () => {
     *   toast.error('播放无延迟异常，已帮您切换到正常延迟模式');
     *   // TODO 重建播放器并使用正常延迟
     * });
     * ```
     */
    LowLatencyError = "LowLatencyError",
    /**
     * 切换播放器全屏
     */
    ToggleFullScreen = "ToggleFullScreen",
    /**
     * 无延迟下行网络质量
     * @internal
     * @ignore
     */
    DownlinkNetworkQuality = "DownlinkNetworkQuality",
    /**
     * 播放器异常
     * @version 从 v1.2.0 版本不再对外使用
     * @internal
     * @ignore
     */
    PlayerError = "PlayerError",
    /**
     * 防录屏跑马灯异常
     *
     * @example
     * ```js
     * watchCore.player.eventEmitter.on(PlayerEvents.PlayerMarqueeError, () => {
     *   toast.error('跑马灯异常');
     * });
     * ```
     */
    PlayerMarqueeError = "PlayerMarqueeError",
    /**
     * 播放器打点信息改变
     * @version v0.5.0
     *
     * @example
     * ```js
     * watchCore.player.eventEmitter.on(PlayerEvents.PlayerTimeAxisMarkListChange, (params) => {
     *   toast.error('播放器打点信息改变', params);
     * });
     * ```
     */
    PlayerTimeAxisMarkListChange = "PlayerTimeAxisMarkListChange",
    /**
     * 播放器"精彩看点"按钮点击事件
     * @desc 仅适用于移动端正常延迟播放器
     * @version v0.5.0
     */
    PlayerHighlightsBtnClicked = "PlayerHighlightsBtnClicked",
    /**
     * 播放器"实时字幕"切换按钮切换
     * @desc 仅适用于移动端正常延迟播放器
     * @version v0.7.0
     */
    PlayerSubtitleSwitched = "PlayerSubtitleSwitched",
    /**
     * 播放器 UI 控制栏显隐事件
     * @desc 仅适用于移动端正常延迟播放器
     * @version v0.6.0
     */
    PlayerUIControlDisplay = "PlayerUIControlDisplay",
    /**
     * 移动端播放器Loading显示隐藏事件
     * @desc 仅适用于移动端正常延迟播放器
     * @version v0.7.0
     */
    PlayerLoading = "playerLoading",
    /**
     * 回放字幕开启和关闭指定的字幕
     * @desc 仅适用于移动端正常延迟播放器
     * @version v0.9.0
     */
    PlayerUIReplaySubtitleChecked = "PlayerUIReplaySubtitleChecked",
    /**
     * 移动端播放器点击字幕的选择器时触发
     * @desc 仅适用于移动端正常延迟播放器
     * @version v1.7.0
     */
    PlayerUIReplaySubtitleSelectBtnClick = "PlayerUIReplaySubtitleSelectBtnClick",
    /**
     * 移动端播放器设置面板皮肤初始化事件
     * @desc 仅适用于移动端正常延迟播放器
     * @version v1.7.0
     */
    PlayerSetupPanelSkinInit = "PlayerSetupPanelSkinInit",
    /**
     * 移动端播放器头部广告点击事件
     * @desc 仅适用于移动端正常延迟播放器
     * @version v1.10.0
     */
    PlayerHeadAdClicked = "PlayerHeadAdClicked",
    /**
     * 移动端播放器暂停广告点击事件
     * @desc 仅适用于移动端正常延迟播放器
     * @version v1.10.0
     */
    PlayerStopAdClicked = "PlayerStopAdClicked",
    /**
     * 移动端播放器统计信息
     * @desc 仅适用于移动端正常延迟播放器
     * @version v2.1.0
     */
    PlayerStatisticsInfo = "PlayerStatisticsInfo",
    /**
     * 播放器内部时间更新事件
     * @desc 仅适用于移动端正常延迟播放器, pc暂不支持
     * @version v2.2.0
     */
    PlayerInnerTimeUpdate = "PlayerInnerTimeUpdate",
    /**
     * 移动端播放器设置面板改变事件
     * @desc 仅适用于移动端正常延迟播放器
     * @version v2.3.0
     */
    PlayerSetupPanelChange = "PlayerSetupPanelChange",
    /**
     * 播放缓冲状态监测更新事件
     * @desc 仅适用于移动端正常延迟播放器
     * @version v2.5.0
     */
    PlayerLoadingDetectionUpdate = "PlayerLoadingDetectionUpdate",
    /**
     * 播放器全屏状态改变事件
     * @desc 仅适用于移动端正常延迟播放器，仅开启增强全屏功能后生效
     * @version v2.5.0
     */
    PlayerFullscreenChange = "PlayerFullscreenChange",
    /**
     * 导播台推流分辨率调整事件
     * @version v2.9.0
     */
    GuideStreamVideoSizeChange = "GuideStreamVideoSizeChange",
    /**
     * 点播播放器server error事件
     * @version v2.15.0
     */
    VodPlayerServerError = "VodPlayerServerError",
    /**
     * 直播播放器s2j_onPlayerError事件
     * @version v2.15.0
     */
    LivePlayerError = "LivePlayerError",
    /**
     * 进入画中画
     */
    EnterPictureInPicture = "EnterPictureInPicture",
    /**
     * 退出画中画
     */
    LeavePictureInPicture = "LeavePictureInPicture"
}

/**
 * 播放器模块事件回调参数配置
 */
export declare type PlayerEventsRelations = {
    [PlayerEvents.PlayerInfoChange]: {
        /**
         * 播放器信息
         */
        playerInfo: PlayerStoreInfo;
    };
    [PlayerEvents.PlayerWarmUpSettingChange]: {
        /**
         * 暖场信息
         */
        warmUpSetting: PlayerWarmUpSetting;
    };
    [PlayerEvents.VolumeChange]: {
        /**
         * 当前音量
         */
        currentVolume: number;
    };
    [PlayerEvents.LineChange]: {
        /**
         * 当前线路
         */
        currentLine: number;
    };
    [PlayerEvents.QualityLevelChange]: {
        /**
         * 当前清晰度级别
         */
        currentQualityLevel: number;
    };
    [PlayerEvents.RateChange]: {
        /**
         * 当前播放倍速
         */
        currentRate: number;
    };
    [PlayerEvents.TimeUpdate]: {
        /**
         * 当前播放时间，单位：秒
         */
        currentTime: number;
        /**
         * 播放总时长，单位：秒
         */
        durationTime: number;
    };
    [PlayerEvents.BarrageStatusChange]: {
        /**
         * 是否显示弹幕
         */
        barrageShow: boolean;
    };
    [PlayerEvents.HistoryPlay]: {
        /**
         * 续播的时间，单位：秒
         */
        historyTime: number;
    };
    [PlayerEvents.LowLatencyError]: {
        /**
         * 错误码
         */
        errorCode?: string;
        /**
         * 错误原因
         * @version v1.2.0
         */
        reason: PlayerErrorReason;
        /**
         * 错误信息
         */
        message?: string;
    };
    [PlayerEvents.ToggleFullScreen]: {
        /**
         * 是否播放器全屏
         */
        isPlayerFullscreen: boolean;
        /**
         * 当前全屏方案
         * @version v1.2.0
         */
        fullScreenMode: FullScreenMode;
    };
    [PlayerEvents.DownlinkNetworkQuality]: {
        /**
         * 下行网络状态
         */
        downlinkNetworkQuality: DownlinkNetworkQuality;
    };
    [PlayerEvents.PlayerError]: {
        /**
         * 错误原因
         */
        reason: PlayerErrorReason;
    };
    [PlayerEvents.PlayerScriptLoaded]: Record<string, never>;
    [PlayerEvents.PlayerTimeAxisMarkListChange]: {
        /** 打点列表 */
        timeAxisMarkList: TimeAxisMarkInfo[];
    };
    [PlayerEvents.PlayerUIControlDisplay]: {
        /** 当前控制栏显示状态 */
        visible: boolean;
    };
    [PlayerEvents.PlayerSubtitleSwitched]: {
        /** 是否打开 */
        checked: boolean;
    };
    [PlayerEvents.PlayerUIReplaySubtitleChecked]: PlayerUIReplaySubtitleCheckedCallbackParams;
    [PlayerEvents.PlayerUIReplaySubtitleSelectBtnClick]: PlayerUIReplaySubtitleSelectBtnClickCbParams;
    [PlayerEvents.PlayerHeadAdClicked]: PlayerHeadAdClickedCbParams;
    [PlayerEvents.PlayerStopAdClicked]: PlayerStopAdClickedCbParams;
    [PlayerEvents.PlayerStatisticsInfo]: PlayerStatisticsInfoCbParams;
    [PlayerEvents.PlayerInnerTimeUpdate]: PlayerInnerTimeUpdateCbParams;
    [PlayerEvents.PlayerMarqueeError]: {
        /**
         * 错误码
         * @version v2.3.0
         */
        code: string;
    };
    [PlayerEvents.PlayerSetupPanelChange]: {
        /** 是否显示设置面板 */
        isShow: boolean;
    };
    [PlayerEvents.PlayerLoadingDetectionUpdate]: {
        /**
         * 播放缓冲监测提示状态
         */
        type: PlayerLoadingDetectionType;
        /**
         * 播放缓冲监测状态详细信息
         */
        detail?: PlayerDetectionSwitchDetail;
    };
    [PlayerEvents.PlayerFullscreenChange]: {
        /**
         * 是否全屏
         */
        isFullscreen: boolean;
        /**
         * 全屏元素
         */
        fullscreenElement: Element;
    };
    [PlayerEvents.GuideStreamVideoSizeChange]: VideoSize;
    [PlayerEvents.VodPlayerServerError]: {
        /**
         * 错误码
         */
        code: string;
    };
    [PlayerEvents.LivePlayerError]: {
        /** 错误码 */
        errorCode?: string;
        /** 频道号 */
        cid?: string;
    };
    [PlayerEvents.EnterPictureInPicture]: Record<string, never>;
    [PlayerEvents.LeavePictureInPicture]: Record<string, never>;
};

/**
 * 片头广告点击事件回调参数
 */
declare interface PlayerHeadAdClickedCbParams extends PlayerStopAdClickedCbParams {
    /** 广告时长 */
    advertDuration: number;
}

/**
 * 播放器内部时间更新事件回调参数
 */
export declare interface PlayerInnerTimeUpdateCbParams {
    /** 当前播放时间 */
    currentTime: number;
}

/** 播放器线路数据 */
declare interface PlayerLineData {
    multirateModel: PlayerMultirateModel;
}

/** 直播播放器统计 param 参数 */
declare interface PlayerLiveStatParams {
    /** 观众 id */
    param1: string;
    /** 观众昵称 */
    param2: string;
    /** 固定值 */
    param3: 'live';
    param4?: string;
    param5?: string;
    /** 场次号 */
    session_id: string;
    /** 渠道Id */
    fr: string;
}

/**
 * 播放缓冲监测提示状态类型
 */
export declare enum PlayerLoadingDetectionType {
    /** 显示监测切换提示 */
    'SHOW' = 0,
    /** 隐藏监测切换提示 */
    'HIDE' = 1,
    /** 成功切换提示 */
    'SUCCESS' = 2
}

/** 播放器 logo 位置类型 */
export declare type PlayerLogoPosition = 'tl' | 'tr' | 'bl' | 'br';

/**
 * 播放器 logo 设置
 */
export declare interface PlayerLogoSetting {
    /**
     * logo 图片地址
     */
    logoImage: string | undefined;
    /**
     * logo 跳转地址
     */
    logoHref: string | undefined;
    /**
     * logo 透明度
     */
    logoOpacity: number;
    /**
     * logo 位置
     */
    logoPosition: PlayerLogoPosition;
}

/** 播放器码率数据 */
declare interface PlayerMultirateModel {
    /** 默认码率名称 */
    defaultDefinition: string;
    definitions: PlayerMultirateModelItem[];
}

declare interface PlayerMultirateModelItem {
    /** 码率名称 */
    definition: string;
}

/**
 * 播放器比例
 */
export declare enum PlayerResolutionRatio {
    /** 横向 16:9 */
    Horizontal = "horizontal",
    /** 纵向 9:16 */
    Vertical = "vertical"
}

/**
 * 播放器设置
 */
export declare interface PlayerSetting {
    /**
     * 播放器是否支持全屏
     * @version v0.8.0
     */
    playerFullscreenEnabled: boolean;
    /**
     * 竖屏播放器是否支持全屏
     * @version v0.8.0
     */
    portraitPlayerFullscreenEnabled: boolean;
    /**
     * 移动端音视频切换开关
     */
    mobileAudioEnabled: boolean;
    /**
     * 播放器全屏模式
     */
    fullScreenMode: FullScreenMode;
}

/**
 * 移动端播放器统计信息回调参数
 */
export declare interface PlayerStatisticsInfoCbParams {
    /** 实际播放时长 */
    pd: string;
    /** 停留时长 */
    sd: string;
}

/**
 * 暂停广告点击事件回调参数
 */
declare interface PlayerStopAdClickedCbParams {
    /** 跳转地址，不包括微信的场景 */
    href: string;
    /** 跳转方式，a标签的target */
    target: string;
    /** 是否开启自定义 */
    isCustom: boolean;
}

/**
 * 播放器信息
 */
export declare interface PlayerStoreInfo {
    /**
     * 播放器是否初始化完成
     */
    playerInited: boolean;
    /**
     * 是否支持刷新
     */
    supportRefresh: boolean;
    /**
     * 是否支持自动播放
     */
    supportAutoPlay: boolean;
    /**
     * 是否支持多语流
     * @version v0.8.0
     * @warn 从 v1.8.0 版本开始，建议改用 `channel.getChannelStreamTrackConfig` 来获取相关配置
     */
    supportLanguageStream: boolean;
    /**
     * 是否支持无延迟播放
     */
    supportLowLatency: boolean;
    /**
     * 当前是否无延迟播放
     */
    isLowLatency: boolean;
    /**
     * 播放状态
     */
    playStatus: PlayStatus;
    /**
     * 弹幕显示状态
     */
    barrageShow: boolean;
    /**
     * 是否支持弹幕速度切换
     */
    supportBarrageSpeed: boolean;
    /**
     * 弹幕速度
     */
    currentBarrageSpeed: number;
    /**
     * 弹幕速度默认档位
     * @version v0.9.0
     */
    barrageSpeedDefaultGrade: number;
    /**
     * 是否支持弹幕字号切换
     * @version v0.9.0
     */
    supportBarrageSize: boolean;
    /**
     * 弹幕字号
     * @version v0.9.0
     */
    currentBarrageSize: number;
    /**
     * 弹幕字号默认档位
     * @version v0.9.0
     */
    barrageSizeDefaultGrade: number;
    /**
     * 是否支持弹幕字号切换
     * @version v0.11.0
     */
    supportBarrageLocation: boolean;
    /**
     * 默认弹幕位置ID
     * @version v0.11.0
     */
    barrageLocationDefaultId: number;
    /**
     * 当前弹幕位置ID
     * @version v0.11.0
     */
    currentBarrageLocationIndex: number;
    /**
     * 是否支持弹幕透明度切换
     * @version v0.11.0
     */
    supportBarrageAlpha: boolean;
    /**
     * 默认弹幕透明度
     * @version v0.11.0
     */
    barrageDefaultAlpha: number;
    /**
     * 当前弹幕透明度
     * @version v0.11.0
     */
    currentBarrageAlpha: number;
    /**
     * 当前音量
     */
    currentVolume: number;
    /**
     * 总线路数
     */
    lineCount: number;
    /**
     * 当前线路索引
     */
    currentLine: number;
    /**
     * 可选的清晰度列表
     */
    qualityLevels: QualityLevelItem[];
    /**
     * 当前清晰度级别
     */
    currentQualityLevel: number;
    /**
     * 可选的倍速列表
     */
    rateList: number[];
    /**
     * 当前倍速
     */
    currentRate: number;
    /**
     * 播放总时长，单位：秒
     */
    durationTime: number;
    /**
     * 当前播放进度，单位：秒
     */
    currentTime: number;
    /**
     * 延迟时间，单位：毫秒
     * @internal
     * @ignore
     */
    delayTime: number;
    /**
     * 是否支持时间轴标记
     * @version v0.5.0
     */
    supportTimeAxisMark: boolean;
    /**
     * 是否支持直播时移
     * @version v0.5.0
     */
    supportLiveTimeShift: boolean;
    /**
     * 直播时是否显示播放按钮， 默认开
     * @version v0.10.0
     */
    stopLivePlayEnabled: boolean;
    /**
     * 回放时是否显示倍速按钮，默认开
     * @version v1.2.0
     */
    playbackMultiplierEnabled: boolean;
    /**
     * 回放时是否显示进度条，默认开
     * @version v1.2.0
     */
    playbackProgressBarEnabled: boolean;
    /**
     * 回放时是否显示左下角播放/暂停按钮，默认开
     * @version v1.2.0
     */
    playbackShowPlayButtonEnabled: boolean;
    /**
     * 回放时是否循环播放，列表播放播放完最后一个视频会暂停播放，默认开
     * @version v1.10.0
     */
    loopPlayEnabled: boolean;
    /**
     * 是否开启播放器新版暂停样式
     * @version v1.0.0
     */
    newPlayerPauseStyleEnabled: boolean;
    /**
     * 录制文件音频流地址
     * @version v1.7.0
     */
    recordFileAudioUrl: string;
    /**
     * 播放器比例
     * @version v2.1.0
     */
    playerResolutionRatio: PlayerResolutionRatio;
    /**
     * 连麦时，无延迟停止流操作是否需要延迟执行，默认 false
     * @version v2.13.0
     */
    needWaitToStop: boolean;
    /**
     * 竖屏播放器画面适配类型
     * @version v2.14.0
     */
    portraitPlayerScreenType: PortraitPlayerScreenType;
}

declare interface PlayerTimeShiftData extends TimeShiftStreamInfo {
    /**
     * 是否支持时移功能
     * @internal
     * @desc 外部需要使用 getSupportTimeShift 来判断是否支持时移
     * */
    timeShiftEnabled: boolean;
}

declare interface PlayerUIReplaySubtitleCheckedCallbackParams extends ReplaySubtitleItem {
    checked: boolean;
    index: number;
}

declare interface PlayerUIReplaySubtitleSelectBtnClickCbParams extends playbackMultipleSubtitleOptions {
    index: number;
}

/**
 * 播放器视频信息
 */
export declare interface PlayerVideoInfo {
    /** 视频宽度 */
    videoWidth?: number;
    /** 视频高度 */
    videoHeight?: number;
}

/**
 * 播放器暖场设置
 */
export declare interface PlayerWarmUpSetting {
    /**
     * 暖场类型
     */
    warmUpType?: WarmUpType;
    /**
     * 暖场图片地址
     */
    warmUpImg?: string;
    /**
     * 暖场大图图片地址
     * @version v1.8.0
     */
    warmUpLargeImg?: string;
    /**
     * 暖场视频地址
     */
    warmUpVideo?: string;
    /**
     * 暖场图片点击跳转地址
     */
    warmUpHref?: string;
}

/**
 * 播放状态
 */
export declare enum PlayStatus {
    /**
     * 播放中
     */
    Playing = "playing",
    /**
     * 已暂停
     */
    Pause = "pause"
}

/**
 * AI 助手模块
 * @class
 * @desc AI 助手不一定需要用到用户信息，可以单独被使用
 */
declare class PlvAIAssistantModule extends ModuleBase_2 {
    /** 事件触发器 */
    eventEmitter: EventEmitter<AIAssistantEventsRelations, AIAssistantEvents>;
    /**
     * AI 助手独立模式
     */
    private __aiAssistantIndependentMode;
    /**
     * AI 助手预览模式
     */
    private __aiPreviewMode;
    /**
     * 是否使用 AI Token
     */
    private get __useAIToken();
    /**
     * 是否支持 AI 助手聊天功能
     */
    supportAIAssistantChat(): SupportResult_2;
    /**
     * @ignore
     * @internal
     */
    setup(): void;
    /**
     * 生成默认的 AI 助手相关配置
     */
    static generateDefaultAIAssistantConfig(): PolyvAIAssistantConfig;
    /** AI 助手相关配置 */
    private __aiAssistantConfig;
    /**
     * 设置 AI 助手相关配置
     */
    private __setupAIAssistantConfig;
    /**
     * 获取 AI 助手相关配置
     */
    getAIAssistantConfig(): PolyvAIAssistantConfig;
    /**
     * 生成默认的 AI 助手相关配置
     */
    static generateDefaultAIAssistantInfo(): PolyvAIAssistantInfo;
    /** AI 助手相关配置 */
    private __aiAssistantInfo;
    /**
     * 获取 AI 助手信息
     *
     * @description 获取当前 AI 助手的配置信息，包括助手 ID、名称、数字人信息等
     * @returns AI 助手信息对象
     *
     * @example
     * ```typescript
     * const assistantModule = new AIAssistantModule();
     * await assistantModule.setupAIAssistant({ aiAssistantCode: 'xxx' });
     * const info = assistantModule.getAIAssistantInfo();
     * console.log('助手ID:', info.aiAssistantId);
     * console.log('助手名称:', info.aiAssistantName);
     * console.log('欢迎语:', info.welcomeSpeech);
     * console.log('数字人ID:', info.digitalHumanId);
     * console.log('数字人名称:', info.digitalHumanName);
     * console.log('说话视频地址:', info.videoSource?.speakUrl);
     * console.log('不说话视频地址:', info.videoSource?.noSpeakUrl);
     * ```
     */
    getAIAssistantInfo(): PolyvAIAssistantInfo;
    /**
     * 初始化完整的 AI 配置
     */
    private __setupCompleteAIAssistantConfig;
    /**
     * 初始化 AI 助手
     */
    setupAIAssistant(aiAssistantInfo: Partial<PolyvAIAssistantInfo>, opts?: {
        independent?: boolean;
        previewMode?: boolean;
    }): Promise<void>;
    /**
     * AI 助手聊天室 Token
     * @internal
     */
    private __aiChatToken;
    /**
     * 获取 AI 助手聊天室 Token
     *
     * @description 获取用于 AI 助手聊天的身份令牌。优先使用传入的 chatToken，如果未传入则通过 API 获取
     * @internal
     * @returns AI 助手聊天室 Token 字符串
     * @throws 如果无法获取 Token 则抛出错误
     */
    private __getAiChatToken;
    /**
     * AI 助手聊天状态
     * @internal
     */
    private __AIAssistantChatStatus;
    /**
     * 更新 AI 助手聊天状态
     *
     * @description 内部方法，用于更新 AI 助手当前的聊天状态并触发状态变更事件
     * @param status - 新的聊天状态
     * @internal
     */
    protected _updateAIAssistantChatStatus(status: PolyvAIAssistantChatStatus): void;
    /**
     * 生成 AI 助手消息用户信息
     *
     * @description 创建表示 AI 助手本身的用户信息对象，用于发送消息时标识发送者
     * @internal
     * @returns AI 助手消息用户对象，包含用户 ID 和昵称
     */
    private __generateAIAssistantMsgUser;
    /**
     * 生成当前用户消息信息
     *
     * @description 获取当前登录用户的信息，用于发送提问消息时标识发送者
     * @internal
     * @returns 当前用户消息对象
     */
    private __generateCurrentMsgUser;
    /**
     * 发送 AI 提问消息
     *
     * 用于观众发送提问消息给到 AI 助手，调用过程中会触发 {@link AIAssistantEvents.AIAssistantChatStatusChange} 、{@link AIAssistantEvents.AIAssistantChatMessage}、{@link AIAssistantEvents.ReplaceAIAssistantChatMessage} 等事件。
     */
    sendAIQuestionMsg({ content }: SendAIQuestionMsgOptions): Promise<void>;
    /**
     * 获取 AI 助手聊天历史
     *
     * @description 获取当前用户与 AI 助手的聊天历史记录，包括问题和答案
     * @returns 聊天消息数组，按时间顺序排列
     * @throws 如果无法获取 chatToken 则抛出错误
     *
     * @example
     * ```typescript
     * const assistantModule = new AIAssistantModule();
     * try {
     *   const history = await assistantModule.getAIAssistantChatHistory();
     *   console.log('历史消息数量:', history.length);
     *
     *   history.forEach(msg => {
     *     if (msg.msgSource === PolyvAIAssistantChatMsgSource.Question) {
     *       console.log('【用户提问】:', msg.content);
     *     } else {
     *       console.log('【AI 回答】:', msg.content);
     *     }
     *   });
     * } catch (error) {
     *   console.error('获取聊天历史失败:', error);
     * }
     * ```
     */
    getAIAssistantChatHistory(): Promise<PolyvAIAssistantChatMsgType[]>;
    /**
     * 创建 AI 助手音频合成任务
     *
     * @description 将文本转换为语音并生成音频文件，支持自定义语速和语音类型
     * @param opts - 音频合成参数
     * @param opts.rate - 语速倍率，默认 1（正常速度），范围 0.5-2
     * @param opts.text - 要转换的文本内容，必填
     * @param opts.ttsVoiceId - 语音 ID，可选，不同的 ID 代表不同的语音风格
     * @returns 包含任务 ID 的对象，用于后续获取音频结果
     * @throws 如果 text 为空则抛出错误
     *
     * @example
     * ```typescript
     * const assistantModule = new AIAssistantModule();
     *
     * // 创建音频合成任务
     * const { taskId } = await assistantModule.createAiAssistantAudioTask({
     *   text: '欢迎观看直播，这是 AI 助手为您生成的语音内容',
     *   rate: 1,
     *   ttsVoiceId: 'female_zh_1'
     * });
     * console.log('任务ID:', taskId);
     *
     * // 等待一段时间后获取音频结果
     * const audioResult = await assistantModule.getAiAssistantAudioTaskResult(taskId);
     * console.log('音频URL:', audioResult.audioUrl);
     * ```
     */
    createAiAssistantAudioTask(opts: {
        rate?: number;
        text: string;
        ttsVoiceId?: string;
    }): Promise<{
        taskId: string;
    }>;
    /**
     * 获取 AI 助手音频合成任务结果
     *
     * @description 根据任务 ID 获取之前创建的音频合成任务的结果，包括音频 URL 和状态
     * @param taskId - 音频合成任务 ID（通过 createAiAssistantAudioTask 获取）
     * @returns 音频任务结果对象，包含音频地址和状态信息
     */
    getAiAssistantAudioTaskResult(taskId: string): Promise<PostAiAssistantGetAudioTaskResultResponseData>;
    /**
     * 识别音频转文字
     *
     * @description 将用户上传的音频文件识别并转换为文字内容
     * @param params - 音频识别参数
     * @param params.audioBlob - 音频数据 Blob 对象，必填
     * @param params.audioType - 音频格式类型，默认 'wav'，可选 'mp3'、'wav'、'm4a' 等
     * @returns 识别出的文字内容
     *
     * @example
     * ```typescript
     * const assistantModule = new AIAssistantModule();
     *
     * // 假设已有音频 blob
     * const audioBlob = new Blob([audioData], { type: 'audio/wav' });
     *
     * try {
     *   const text = await assistantModule.recognizeAudioBlobToText({
     *     audioBlob,
     *     audioType: 'wav'
     *   });
     *   console.log('识别结果:', text);
     *
     *   // 可以将识别结果发送给 AI 助手
     *   await assistantModule.sendAIQuestionMsg({ content: text });
     * } catch (error) {
     *   console.error('音频识别失败:', error);
     * }
     * ```
     */
    recognizeAudioBlobToText(params: {
        audioBlob: Blob;
        audioType?: string;
    }): Promise<string>;
    /**
     * @internal
     * @ignore
     */
    destroy(): void;
}

/**
 * AI 总结模块
 * @class
 */
declare class PlvAISummaryModule extends ModuleBase_2 {
    private __subtitleParseLogicService;
    /**
     * 获取回放大纲内容
     *
     * @description 通过大纲 URL 获取回放大纲的详细内容，包括摘要和分段总结
     * @param outlineUrl - 大纲数据的 API URL
     * @returns 回放大纲数据，包含 introduction（摘要）和 outlineContent（分段总结）
     * @throws 如果请求失败会抛出错误
     *
     * @example
     * ```typescript
     * const summaryModule = new AISummaryModule();
     * const outlineUrl = 'https://api.example.com/outline/123';
     * try {
     *   const outlineData = await summaryModule.getOutlineContent(outlineUrl);
     *   console.log('大纲摘要:', outlineData.introduction);
     *   console.log('分段数量:', outlineData.outlineContent.length);
     * } catch (error) {
     *   console.error('获取大纲内容失败:', error);
     * }
     * ```
     */
    getOutlineContent(outlineUrl: string): Promise<PlaybackOutlineData>;
    /**
     * 获取回放大纲数据
     *
     * @description 根据回放 ID 和类型获取对应的大纲数据。首先通过 API 获取大纲 URL，然后使用 getOutlineContent 获取详细内容。
     * @param options - 获取参数，包含回放 ID 和类型
     * @param options.id - 回放 ID（文件 ID 或视频 ID）
     * @param options.type - 回放类型：'record'（录制文件）或 'playback'（回放视频）
     * @returns 回放大纲数据，如果未找到大纲则返回 undefined
     * @throws 如果请求失败会抛出错误
     *
     * @example
     * ```typescript
     * const summaryModule = new AISummaryModule();
     *
     * // 获取录制文件的大纲
     * const recordOptions = {
     *   id: 'file_123456',
     *   type: 'record' as const,
     * };
     * const recordOutline = await summaryModule.getPlaybackOutline(recordOptions);
     * if (recordOutline) {
     *   console.log('录制文件大纲:', recordOutline.introduction);
     * }
     *
     * // 获取回放视频的大纲
     * const playbackOptions = {
     *   id: 'video_789012',
     *   type: 'playback' as const,
     * };
     * const playbackOutline = await summaryModule.getPlaybackOutline(playbackOptions);
     * if (playbackOutline) {
     *   console.log('回放视频大纲分段:', playbackOutline.outlineContent.length);
     * }
     * ```
     */
    getPlaybackOutline(options: PlaybackOutlineOptions): Promise<PlaybackOutlineData | undefined>;
    /**
     * 获取字幕内容
     *
     * @description 通过字幕 URL 获取 AI 生成的字幕文本内容（通常为 SRT 格式）
     * @param url - 字幕数据的 API URL
     * @returns 字幕文本内容（字符串格式）
     * @throws 如果请求失败会抛出错误
     *
     * @example
     * ```typescript
     * const summaryModule = new AISummaryModule();
     * const subtitleUrl = 'https://api.example.com/subtitle/123.srt';
     * try {
     *   const subtitleContent = await summaryModule.getAISubtitleContent(subtitleUrl);
     *   console.log('字幕内容:', subtitleContent);
     *   // 通常返回 SRT 格式文本，可以进一步使用 parseAISubtitleContent 解析
     *   const parsedItems = summaryModule.parseAISubtitleContent(subtitleContent);
     *   console.log('解析后的字幕条目数:', parsedItems.length);
     * } catch (error) {
     *   console.error('获取字幕内容失败:', error);
     * }
     * ```
     */
    getAISubtitleContent(url: string): Promise<string>;
    /**
     * 解析字幕
     *
     * @description 将 SRT 格式的字幕文本解析为结构化的字幕条目数组
     * @param content - SRT 格式的字幕文本
     * @returns 解析后的字幕条目数组，每个条目包含开始时间、结束时间、文本内容和索引
     *
     * @example
     * ```typescript
     * const summaryModule = new AISummaryModule();
     * const srtContent = `
     * 1
     * 00:00:01,000 --> 00:00:04,000
     * 欢迎观看本视频
     *
     * 2
     * 00:00:05,000 --> 00:00:08,000
     * 今天我们将学习 AI 技术
     * `;
     *
     * const parsedItems = summaryModule.parseAISubtitleContent(srtContent);
     * console.log('解析结果:', parsedItems);
     * // 输出示例:
     * // [
     * //   {
     * //     start: 1000,
     * //     end: 4000,
     * //     text: '欢迎观看本视频',
     * //     index: '1'
     * //   },
     * //   {
     * //     start: 5000,
     * //     end: 8000,
     * //     text: '今天我们将学习 AI 技术',
     * //     index: '2'
     * //   }
     * // ]
     *
     * // 使用解析后的数据
     * parsedItems.forEach(item => {
     *   console.log(`时间: ${item.start}-${item.end}ms, 内容: ${item.text}`);
     * });
     * ```
     */
    parseAISubtitleContent(content: string): AISubtitleParsedItem[];
    /**
     * 获取互动答题列表
     *
     * @description 通过答题数据 URL 获取回放视频中的互动答题列表
     * @param url - 互动答题数据的 API URL（JSON 格式）
     * @returns 互动答题数据，包含问题列表
     * @throws 如果请求失败会抛出错误
     *
     * @example
     * ```typescript
     * const summaryModule = new AISummaryModule();
     * const questionUrl = 'https://api.example.com/questions/123.json';
     * try {
     *   const questionData = await summaryModule.getAIPlaybackQuestionData(questionUrl);
     *   console.log('问题数量:', questionData.questions.length);
     *
     *   questionData.questions.forEach((question, index) => {
     *     console.log(`问题 ${index + 1}: ${question.question}`);
     *     console.log(`类型: ${question.type}, 答案: ${question.answer}`);
     *     console.log(`弹题时间: ${question.questionTriggerTime}秒`);
     *
     *     question.selectOptions.forEach(option => {
     *       console.log(`  选项 ${option.option}: ${option.content}`);
     *     });
     *   });
     * } catch (error) {
     *   console.error('获取答题数据失败:', error);
     * }
     * ```
     */
    getAIPlaybackQuestionData(url: string): Promise<PlaybackQuestionData>;
}

/**
 * 提问模块
 * @class
 */
export declare class PlvAskModule extends ModuleBase {
    /** 事件触发器 */
    eventEmitter: EventEmitter<AskEventsRelations, AskEvents>;
    /** 提问模块 Socket 服务 */
    private __askSocketService;
    /** 提问SDK */
    private __askSdk?;
    /**
     * 待替换的提问列表
     */
    private __waitReplaceAskList;
    /**
     * 获取提问SDK
     * @version v0.4.0
     * @warn 从 v0.12.0 开始改成异步处理
     */
    getAskSdk(): Promise<Ask>;
    /**
     * socket 事件绑定钩子
     * @internal
     * @ignore
     * */
    bindSocketEvents(): void;
    /**
     * 获取提问设置
     */
    getAskSetting(): AskSetting;
    /**
     * 根据观众id获取提问记录
     * @version v2.0.0
     */
    getAskHistoryByUserId(params?: GetAskHistoryParamsNew): Promise<AskHistoryResultNew>;
    /**
     * 过滤提问消息是否与我相关
     * @param msg 提问消息
     */
    __isSelfRelevant(msg: AskApiMsgType): boolean;
    /**
     * 过滤提问消息
     */
    private __filterAskApiMsgList;
    /**
     * 过滤提问消息
     * @param apiMsg 提问消息
     */
    __filterAskApiMsg(apiMsg: AskApiMsgType): AskMsgType;
    /**
     * 过滤提问消息
     * @param apiMsg 提问消息
     */
    __filterAskApiSpeak(apiMsg: AskApiMsgType): ChatMsgSpeakType;
    /**
     * 过滤提问消息
     * @param apiMsg 提问消息
     */
    __filterAskApiImage(apiMsg: AskApiMsgType): ChatMsgImageType;
    /**
     * 获取当前提问用户信息
     *
     * @internal
     * @ignore
     */
    getCurrentAskMsgUserData(): ChatMessageUser<ChatUserType>;
    /**
     * 发送提问发言消息
     * @api
     */
    sendAskSpeak(options: SendAskSpeakOptions): Promise<void>;
    replaceAskMsg(replaceMsgId: string, newAskMsg: AskMsgType): void;
    /**
     * @ignore
     * @internal
     */
    getWaitReplaceAskList(): WaitReplaceAskMsgList;
    /**
     * @ignore
     * @internal
     * @version v1.8.0
     */
    shiftWaitReplaceAskListItem(): void;
    /**
     * 发送提问图片消息
     * @api
     */
    sendAskImage(options: SendAskImageOptions): Promise<void>;
    /**
     * 发送系统消息
     *
     * 用于发送系统消息到提问区，注意该消息并不会发送到服务端，调用过程中会触发 {@link AskEvents.SystemMessage} 聊天消息事件。
     * @category 发送聊天消息
     * @param content 消息内容
     * @example
     * ```js
     * watchCore.chat.sendSystemMsg('聊天室已关闭');
     * ```
     */
    sendSystemMsg(content: string, type?: string): void;
    /**
     * 初始化提问SDK
     * @version v0.4.0
     */
    private __createAskSdk;
    destroy(): Promise<void>;
    /**
     * 发送 socket
     * @internal
     * @ignore
     * @param type socket 类型
     * @param data 数据
     * @param parseCallback 是否 JSON.parse 回调
     */
    emitChatWs<C extends unknown[] = []>(type: SocketTypes, data: object, parseCallback?: boolean): Promise<C>;
    /**
     * 根据提问id删除对应的提问数据
     * @version v1.3.0
     * @param id 提问id
     */
    removeAskMsg(id: string): void;
}

/**
 * 观看条件模块
 * @class
 */
export declare class PlvAuthModule extends ModuleBase {
    /**
     * 判断当前用户是否已进行观看条件授权
     * @returns 是否完成授权
     * @example
     * ```js
     * const isAuthorized = watchCore.auth.isAuthorized();
     * if (isAuthorized) {
     *   console.log('观众已进行观看条件授权，进入观看页');
     * } else {
     *   console.log('观众未进行观看条件授权，进入引导页进行授权');
     * }
     * ```
     */
    isAuthorized(): boolean;
    /**
     * 获取观看条件设置列表
     *
     * 各观看条件的设置说明可见对应的文档。
     * - 当后台未开启观看限制，设置列表返回 [无条件授权]
     * - 当后台开启观看限制，设置列表返回 [主要观看条件, 次要观看条件]
     * @returns 观看条件设置列表
     * @example
     * ```js
     * const authSettings = watchCore.auth.getAuthSettings();
     * authSettings.forEach(settingItem => {
     *   console.log('设置类型信息', settingItem);
     *   console.log('设置类型', settingItem.authType);
     * });
     * ```
     */
    getAuthSettings(): AuthSettingItem[];
    /**
     * 验证无条件观看/公开观看
     *
     * 当没有设置观看限制且管理后台开启引导页时，需要进行无条件观看/公开观看验证才可以进入直播观看页。
     * @returns 授权结果
     * @example
     * ```js
     * // 执行无条件授权
     * async function toDoAuthNone() {
     *   const result = await watchCore.auth.verifyNoneAuth();
     *   if (result.success) {
     *     await handleAuthVerifySuccess(result);
     *   } else {
     *     await handleAuthVerifyFail(result);
     *   }
     * }
     * ```
     */
    verifyNoneAuth(): Promise<VerifyNoneAuthResult>;
    /**
     * 验证白名单观看
     * @param params 白名单参数
     * @returns 授权结果
     * @example
     * ```js
     * // 执行白名单授权
     * async function toDoAuthPhone(phone) {
     *   const result = await watchCore.auth.verifyPhoneAuth({
     *     phone,
     *   });
     *   if (result.success) {
     *     await handleAuthVerifySuccess(result);
     *   } else {
     *     await handleAuthVerifyFail(result);
     *   }
     * }
     * ```
     */
    verifyPhoneAuth(params: VerifyPhoneAuthParams): Promise<VerifyPhoneAuthResult>;
    /**
     * 支付状态检查定时器
     */
    private __checkPayStatusTimer?;
    /**
     * 微信支付状态检查定时器
     */
    private __wechatPayCheckTimer?;
    /**
     * 当前支付 id
     */
    private __currentPayId?;
    /**
     * 当前微信订单 id
     */
    private __currentLogId?;
    /**
     * 获取付费观看的支付信息
     *
     * 用于获取观众进行付费观看的支付信息，如：PC 端的支付二维码、微信 H5 的微信支付签名等，调用后可根据支付 id `payId` 查询观众的付费状态。
     * @returns 支付数据
     * @example
     * ```js
     * const { success, ...payData } = await watchCore.auth.getAuthPayData();
     * if(!success) return
     * console.log('支付 id', payData.payId);
     * console.log('微信支付地址', payData.codeUrl); // PC 端下使用
     * console.log('微信支付二维码图片地址', payData.qrcodeUrl); // PC 端下使用
     * console.log('微信 H5 支付签名', payData.wxPaySignData); // 微信 H5 下使用
     * ```
     */
    getAuthPayData(): Promise<CommonResult<AuthPayFailReason, AuthPayData>>;
    /**
     * 获取付费观看的支付状态
     *
     * 当调用 `getAuthPayData` 后，根据返回的 `payId` 查询支付状态，返回 `true` 时表示支付成功，随后即可进入观看页。
     * @param payId 支付 id
     * @returns 是否支付成功
     * @example
     * ```js
     * // 获取支付数据
     * const payData = await watchCore.auth.getAuthPayData();
     * // 检查支付状态
     * const payStatus = await watchCore.auth.checkPayStatus(payData.payId);
     * // 支付成功
     * if (payStatus) {
     *   toast.success('支付成功');
     *   handleAuthVerifySuccess({
     *     success: true,
     *     authType: AuthType.Pay,
     *   });
     * }
     * ```
     */
    checkPayStatus(payId?: string): Promise<boolean>;
    /**
     * 启动支付状态检查轮询
     * @param options 调用参数
     */
    startCheckPayStatusPolling(options?: StartCheckAuthPayStatusTimerOptions): void;
    /**
     * 结束支付状态检查轮询
     */
    closeCheckPayStatusPolling(): void;
    /**
     * 获取微信扫码观看信息
     *
     * 已付费过的观众可以通过微信扫描二维码直接进入观看页，无需二次支付，通过该方法获取扫码信息，调用后可根据记录 id `logId` 查询观众的扫码状态。
     * @returns 微信扫码观看信息
     * @example
     * ```js
     * const wechatQrcodeData = await watchCore.auth.getWechatPayCheckData();
     * console.log('记录 id', wechatQrcodeData.logId);
     * console.log('微信扫描二维码图片地址', wechatQrcodeData.qrcodeUrl);
     * console.log('二维码内容', wechatQrcodeData.codeUrl);
     * ```
     */
    getWechatPayCheckData(): Promise<AuthWechatPayCheckData>;
    /**
     * 获取微信扫码观看状态
     *
     * 当调用 `getWechatPayCheckData` 后，根据返回的 `logId` 查询支付状态，返回 `true` 时表示使用已支付的微信扫码，随后即可进入观看页。
     * @param logId 记录 id
     * @returns 是否使用已支付的微信扫码成功
     * @example
     * ```js
     * // 获取扫码数据
     * const wechatQrcodeData = await watchCore.auth.getWechatPayCheckData();
     * // 检查扫码状态
     * const status = await watchCore.auth.checkWechatPayStatus(wechatQrcodeData.logId);
     * // 扫码成功
     * if (status) {
     *   toast.success('扫码成功');
     *   handleAuthVerifySuccess({
     *     success: true,
     *     authType: AuthType.Pay,
     *   });
     * }
     * ```
     */
    checkWechatPayStatus(logId?: string): Promise<boolean>;
    /**
     * 开启微信支付状态检查轮询
     */
    startCheckWechatPayStatusPolling(options?: StartCheckWechatPayStatusPollingOptions): void;
    /**
     * 结束微信支付状态检查轮询
     */
    closeCheckWechatPayStatusPolling(): void;
    /**
     * 验证验证码观看
     * @param params 调用参数
     * @returns 授权结果
     * @example
     * ```js
     * // 执行验证码授权
     * async function toDoAuthCode(code) {
     *   const result = await watchCore.auth.verifyCodeAuth({
     *     code,
     *   });
     *   if (result.success) {
     *     await handleAuthVerifySuccess(result);
     *   } else {
     *     await handleAuthVerifyFail(result);
     *   }
     * }
     *
     * // 传入验证码
     * toDoAuthCode('1234');
     * ```
     */
    verifyCodeAuth(params: VerifyCodeAuthParams): Promise<VerifyCodeAuthResult>;
    /**
     * 获取登记观看表单设置列表
     * @returns 表单设置列表
     * @example
     * ```js
     * const formFields = watchCore.auth.getAuthInfoFields();
     * formFields.forEach(fieldItem => {
     *   console.log('表单项信息', fieldItem);
     *   console.log('表单类型', fieldItem.type);
     * });
     * ```
     */
    getAuthInfoFields(): AuthInfoItem[];
    /**
     * 验证登记观看
     *
     * 通过 `verifyInfoAuth` 传入 `formValues` 进行验证登记观看，如果后台设置了手机号码的登记选项，需要另外传入 `phoneNumber`、`areaCode`、`smsCore` 这三个字段。
     * @param params 调用参数
     * @returns 授权结果
     * @example
     * ```js
     * // 登记观看表单列表结构示例：
     * // [mobile(手机号码), name(姓名), text(职业), number(年龄), option(城市->广州,深圳,佛山,惠州)]
     *
     * // 执行登记观看验证
     * async function toDoAuthInfo(form) {
     *   const result = await watchCore.auth.verifyInfoAuth({
     *     code,
     *   });
     *   if (result.success) {
     *     await handleAuthVerifySuccess(result);
     *   } else {
     *     await handleAuthVerifyFail(result);
     *   }
     * }
     * // 提交的表单内容
     * toDoAuthInfo({
     *   phoneNumber: '18012345678',
     *   areaCode: '+86',
     *   smsCode: '76431',
     *   formValues: ['18012345678', '李小明', '前端开发工程师', '18', '广州'],
     * });
     * ```
     */
    verifyInfoAuth(params: VerifyInfoAuthParam): Promise<VerifyInfoAuthResult>;
    /**
     * 登录登记观看
     *
     * 当后台设置了手机号码的表单选项后，如果观众已提交过登记表单时，可调用 `loginInfoAuth` 方法，传入手机号码信息进行验证，如果已存在登记信息则可直接进入观看页。
     * @param params 调用参数
     * @returns 登录结果
     * @example
     * ```js
     * async function submitAuthLogin(phoneNumber, areaCode) {
     *   const result = await watchCore.auth.loginInfoAuth({
     *     phoneNumber: phoneNumber,
     *     areaCode: areaCode,
     *   });
     *   if (result.success) {
     *     handleAuthVerifySuccess(result);
     *   } else {
     *     handleAuthVerifyFail(result);
     *   }
     * }
     * ```
     */
    loginInfoAuth(params: LoginInfoAuthParams): Promise<LoginInfoAuthResult>;
    /**
     * 自定义授权 token 本地缓存 key 前缀
     * @internal
     * @ignore
     */
    static customAuthTokenStorageKeyPrefix: string;
    /**
     * 获取自定义授权 token 本地存储 key
     */
    private __getCustomAuthTokenStorageKey;
    /**
     * 获取自定义授权的地址
     *
     * 当用户点击授权按钮时，通过该方法获取自定义授权链接并进行跳转。
     * @returns 自定义授权跳转地址信息
     * @example
     * ```js
     * document.querySelector('button').addEvenListener('click', async () => {
     *   const data = await watchCore.auth.getCustomAuthUrl();
     *   window.location.href = data.customAuthUrl;
     * });
     * ```
     */
    getCustomAuthUrl(): Promise<CustomAuthUrlData>;
    /**
     * 重定向到自定义授权地址
     *
     * 如果不调用 `getCustomAuthUrl` 获取授权地址，开发者可以调用 `redirectCustomAuthUrl` 进行跳转，通过方法返回的结果判断页面是否被跳转。
     * @returns 是否重定向
     * @example
     * ```js
     * const result = await watchCore.auth.redirectCustomAuthUrl();
     * if (result.success) {
     *   console.log('页面已重定向');
     * } else {
     *   console.log('重定向失败，原因：', result.failReason);
     * }
     * ```
     */
    redirectCustomAuthUrl(): Promise<boolean>;
    /**
     * 允许自动重定向到自定义授权地址
     *
     * 授权模块提供方法用于在观众进入观看页，直接重定向到自定义授权地址，无需经过引导页，内部判断条件如下：
     * - 观众未授权
     * - 管理后台只设置了自定义授权
     * - 管理后台关闭引导页开关
     * @returns 是否自动重定向
     * @example
     * ```js
     * const allowAutoRedirect = await watchCore.auth.allowAutoRedirectCustomAuthUrl();
     * // 当前不需要显示引导页，直接跳到自定义授权地址
     * if (allowAutoRedirect) {
     *   watchCore.auth.redirectCustomAuthUrl();
     * }
     * ```
     */
    allowAutoRedirectCustomAuthUrl(): Promise<boolean>;
    /**
     * 是否满足自定义授权所需的签名参数
     */
    private __accordCustomAuthSignParams;
    /**
     * 允许验证自定义授权
     *
     * 从授权平台跳转回观看页后，通过该方法判断当前环境下是否允许进行自定义授权签名验证。
     * @param signParams 授权签名参数
     * @param options 配置项
     * @warn 从 v0.11.0 版本开始，在授权通过，但其他配置是正常的情况下，也允许进行外部授权签名验证。另外通过新增 options 参数，开发者可以设置 `{ ignoreAuthorized:false }` 来达到和之前版本一样的效果
     * @returns 是否允许验证自定义授权
     * @example
     * ```js
     * import { parse } from '@just4/querystring';
     * import { CustomAuthSignParams } from '@polyv/live-watch-sdk';
     *
     * async function example {
     *   const queryParams = parse(window.location.search.slice(1));
     *   const signParams: CustomAuthSignParams = {
     *     userid: queryParams.userid || '',
     *     ts: queryParams.ts || '',
     *     sign: queryParams.sign || '',
     *   };
     *
     *   const allowVerify = watchCore.auth.allowToVerifyCustomAuth(signParams);
     *   if (allowVerify) {
     *     // TODO 验证自定义授权
     *   }
     * }
     * ```
     */
    allowToVerifyCustomAuth(signParams: CustomAuthSignParams, options?: {
        /** 忽略授权情况，默认 true */
        ignoreAuthorized?: boolean;
    }): Promise<boolean>;
    /**
     * 验证自定义授权签名参数
     *
     * 从授权平台跳转回观看页后，通过 `verifyCustomAuth` 进行自定义授权参数验证，在调用前请调用 `allowToVerifyCustomAuth` 判断签名参数是否符合要求。
     * @param signParams 授权参数
     * @param queryParams 链接参数
     * @returns 授权结果
     * @example
     * ```js
     * import { parse } from '@just4/querystring';
     * import { CustomAuthSignParams } from '@polyv/live-watch-sdk';
     *
     * async function example {
     *   const queryParams = parse(window.location.search.slice(1));
     *   const signParams: CustomAuthSignParams = {
     *     userid: queryParams.userid || '',
     *     ts: queryParams.ts || '',
     *     sign: queryParams.sign || '',
     *   };
     *
     *   const allowVerify = watchCore.auth.allowToVerifyCustomAuth(signParams);
     *   if (!allowVerify) {
     *     return;
     *   }
     *
     *   const result = await watchCore.auth.verifyCustomAuth(signParams, queryParams);
     *   if (result.success) {
     *     handleAuthVerifySuccess(result);
     *   } else {
     *     handleAuthVerifyFail(result);
     *   }
     * }
     * ```
     */
    verifyCustomAuth(signParams: CustomAuthSignParams, queryParams: object): Promise<VerifyCustomAuthResult>;
    /**
     * 外部授权登录按钮是否启用
     * @version v0.4.0
     */
    getExternalAuthButtonEnabled(): boolean;
    /**
     * 是否满足外部授权所需的签名参数
     */
    private __accordExternalAuthSignParams;
    /**
     * 允许验证外部授权
     *
     * 从授权平台重定向到观看页后，通过该方法判断当前环境是否允许进行外部授权签名验证。
     * @param signParams 授权签名参数
     * @param options 配置项
     * @warn 从 v0.11.0 版本开始，在授权通过，但其他配置是正常的情况下，也允许进行外部授权签名验证。另外通过新增 options 参数，开发者可以设置 `{ ignoreAuthorized:false }` 来达到和之前版本一样的效果
     * @returns 是否允许验证外部授权
     * @example
     * ```js
     * import { parse } from '@just4/querystring';
     * import { ExternalAuthSignParams } from '@polyv/live-watch-sdk';
     *
     * async function example {
     *   const queryParams = parse(window.location.search.slice(1));
     *   const signParams: ExternalAuthSignParams = {
     *     userid: queryParams.userid || '',
     *     ts: queryParams.ts || '',
     *     sign: queryParams.sign || '',
     *   };
     *
     *   const allowVerify = watchCore.auth.allowToVerifyExternalAuth(signParams);
     *   if (allowVerify) {
     *     // TODO 验证外部授权
     *   }
     * }
     * ```
     */
    allowToVerifyExternalAuth(signParams: ExternalAuthSignParams, options?: {
        /** 忽略授权情况，默认 true */
        ignoreAuthorized?: boolean;
    }): Promise<boolean>;
    /**
     * 验证外部授权签名参数
     *
     * 从授权平台跳转回观看页后，通过 `verifyExternalAuth` 进行外部授权签名参数验证，在调用前请调用 `allowToVerifyExternalAuth` 判断签名参数是否符合要求。
     * @param signParams 授权参数
     * @param queryParams 链接参数
     * @example
     * ```js
     * import { parse } from '@just4/querystring';
     * import { ExternalAuthSignParams } from '@polyv/live-watch-sdk';
     *
     * async function example {
     *   const queryParams = parse(window.location.search.slice(1));
     *   const signParams: ExternalAuthSignParams = {
     *     userid: queryParams.userid || '',
     *     ts: queryParams.ts || '',
     *     sign: queryParams.sign || '',
     *   };
     *
     *   const allowVerify = watchCore.auth.allowToVerifyExternalAuth(signParams);
     *   if (!allowVerify) {
     *     return;
     *   }
     *
     *   const result = await watchCore.auth.verifyExternalAuth(signParams, queryParams);
     *   if (result.success) {
     *     handleAuthVerifySuccess(result);
     *   } else {
     *     handleAuthVerifyFail(result);
     *   }
     * }
     * ```
     */
    verifyExternalAuth(signParams: ExternalAuthSignParams, queryParams: object): Promise<VerifyExternalAuthResult>;
    /**
     * 获取外部授权失败的地址
     *
     * 当外部授权失败或无授权签名参数时，通过该方法获取授权失败自定义 URL 并进行跳转
     * @returns 外部授权失败地址信息
     * @example
     * ```js
     * document.querySelector('button').addEvenListener('click', async () => {
     *   const data = await watchCore.auth.getExternalAuthFailUrl();
     *   window.location.href = data.externalAuthFailUrl;
     * });
     * ```
     */
    getExternalAuthFailUrl(): Promise<ExternalAuthFailUrlData>;
    /**
     * 重定向到外部授权失败地址
     *
     * 如果不调用 `getExternalAuthFailUrl` 获取重定向地址，开发者可以调用 `redirectExternalAuthFailUrl` 进行跳转，通过方法返回的结果判断页面是否被跳转。
     * @returns 是否重定向
     * @example
     * ```js
     * const result = await watchCore.auth.redirectExternalAuthFailUrl();
     * if (result.success) {
     *   console.log('页面已重定向');
     * } else {
     *   console.log('重定向失败，原因：', result.failReason);
     * }
     * ```
     */
    redirectExternalAuthFailUrl(): Promise<boolean>;
    /**
     * 允许自动重定向到外部授权失败页面
     *
     * 当外部授权失败或没有观看页地址没有外部授权签名参数时，通过 `allowAutoRedirectExternalAuthFailUrl` 方法判断是否自动跳转到外部授权失败地址，内部判断条件如下：
     * - 观众未授权
     * - 管理后台只设置了外部授权（除独立授权）
     * @returns 是否自动重定向
     * @example
     * ```js
     * // 验证外部授权失败之后 / 无外部授权签名参数
     * const allowAutoRedirect = await watchCore.auth.allowAutoRedirectExternalAuthFailUrl();
     * if (allowAutoRedirect) {
     *   watchCore.auth.redirectExternalAuthFailUrl();
     * }
     * ```
     */
    allowAutoRedirectExternalAuthFailUrl(): Promise<boolean>;
    /**
     * 是否存在独立授权所需的地址参数
     */
    private __accordDirectAuthSignParams;
    /**
     * 获取是否强制独立授权
     */
    private __getForceDirectAuth;
    /**
     * 允许验证独立授权
     *
     * 从授权平台跳转回观看页后，通过该方法判断当前环境下是否允许进行独立授权签名验证。
     * @param signParams 授权签名参数
     * @param options 配置项
     * @warn 从 v0.11.0 版本开始，在授权通过，但其他配置是正常的情况下，也允许进行外部授权签名验证。另外通过新增 options 参数，开发者可以设置 `{ ignoreAuthorized:false }` 来达到和之前版本一样的效果
     * @returns 是否允许验证独立授权
     * @example
     * ```js
     * import { parse } from '@just4/querystring';
     * import { DirectAuthSignParams } from '@polyv/live-watch-sdk';
     *
     * async function example {
     *   const queryParams = parse(window.location.search.slice(1));
     *   const signParams: DirectAuthSignParams = {
     *     userid: queryParams.userid || '',
     *     ts: queryParams.ts || '',
     *     sign: queryParams.sign || '',
     *     nickname: queryParams.nickname || '',
     *   };
     *
     *   const allowVerify = watchCore.auth.allowToVerifyDirectAuth(signParams);
     *   if (allowVerify) {
     *     // TODO 验证独立授权
     *   }
     * }
     * ```
     */
    allowToVerifyDirectAuth(signParams: DirectAuthSignParams, options?: {
        /** 忽略授权情况，默认 true */
        ignoreAuthorized?: boolean;
    }): Promise<boolean>;
    /**
     * 验证独立授权签名参数
     *
     * 从授权平台跳转回观看页后，通过 `verifyDirectAuth` 进行外部授权签名参数验证，在调用前请调用 `allowToVerifyDirectAuth` 判断签名参数是否符合要求。
     * @param signParams 授权参数
     * @param queryParams 链接参数
     * @example
     * ```js
     * import { parse } from '@just4/querystring';
     * import { ExternalAuthSignParams } from '@polyv/live-watch-sdk';
     *
     * async function example {
     *   const queryParams = parse(window.location.search.slice(1));
     *   const signParams: ExternalAuthSignParams = {
     *     userid: queryParams.userid || '',
     *     ts: queryParams.ts || '',
     *     sign: queryParams.sign || '',
     *     nickname: queryParams.nickname || '',
     *   };
     *
     *   const allowVerify = watchCore.auth.allowToVerifyDirectAuth(signParams);
     *   if (!allowVerify) {
     *     return;
     *   }
     *
     *   const result = await watchCore.auth.verifyDirectAuth(signParams, queryParams);
     *   if (result.success) {
     *     handleAuthVerifySuccess(result);
     *   } else {
     *     handleAuthVerifyFail(result);
     *   }
     * }
     * ```
     */
    verifyDirectAuth(signParams: DirectAuthSignParams, queryParams: object): Promise<VerifyDirectAuthResult>;
    /**
     * 获取独立授权失败的地址
     *
     * @version v2.5.0
     *
     * 当独立授权失败或没有观看页地址没有独立授权签名参数时，通过该方法获取授权失败自定义 URL 并进行跳转
     * @returns 独立授权失败地址信息
     * @example
     * ```js
     * document.querySelector('button').addEvenListener('click', async () => {
     *   const data = await watchCore.auth.getDirectAuthFailUrl();
     *   window.location.href = data.directAuthFailUrl;
     * });
     * ```
     */
    getDirectAuthFailUrl(): Promise<DirectAuthFailUrlData>;
    /**
     * 重定向到独立授权失败地址
     *
     * @version v2.5.0
     * 如果不调用 `getDirectAuthFailUrl` 获取重定向地址，开发者可以调用 `redirectDirectAuthFailUrl` 进行跳转，通过方法返回的结果判断页面是否被跳转。
     * @returns 是否重定向
     * @example
     * ```js
     * const result = await watchCore.auth.redirectDirectAuthFailUrl();
     * if (result) {
     *   console.log('页面已重定向');
     * } else {
     *   console.log('重定向失败');
     * }
     * ```
     */
    redirectDirectAuthFailUrl(): Promise<boolean>;
    /**
     * 允许自动重定向到独立授权失败页面
     *
     * 当独立授权失败或没有观看页地址没有独立授权签名参数时，通过 `allowAutoRedirectDirectAuthFailUrl` 方法判断是否自动跳转到独立授权失败页面，内部判断条件如下：
     * - 观众未授权
     * - 管理后台只设置了独立授权
     * @returns 是否自动重定向
     * @example
     * ```js
     * // 验证独立授权失败之后 / 无独立授权签名参数
     * const allowAutoRedirect = await watchCore.auth.allowAutoRedirectDirectAuthFailUrl();
     * if (allowAutoRedirect) {
     *   watchCore.auth.redirectDirectAuthFailUrl();
     * }
     * ```
     */
    allowAutoRedirectDirectAuthFailUrl(): Promise<boolean>;
    /**
     * 获取邀请观看授权审核状态
     * @version v2.0.0
     */
    getInviteWatchAuthAuditStatus(): InviteWatchAuditStatus;
    /**
     * 是否允许验证邀请观看授权
     * @version v2.0.0
     */
    allowInviteWatchAuth(): boolean;
    /**
     * 验证邀请观看授权
     * @version v2.0.0
     */
    verifyInviteWatchAuth({ saleId, }: VerifyInviteWatchAuthParams): Promise<VerifyInviteWatchAuthResult>;
    /**
     * 获取邀请观看授权信息
     * @version v2.0.0
     */
    getInviteWatchAuthInfo({ saleId, }: VerifyInviteWatchAuthParams): Promise<InviteWatchAuthInfo>;
    /**
     * 获取授权设置
     * @param authType 授权类型
     */
    private __getAuthSettingItem;
    /**
     * 是否存在某个观看条件
     * @param authType 授权类型
     * @internal
     * @ignore
     */
    hasAuth(authType: AuthType): boolean;
    /**
     * 创建成功结果
     * @param authType 授权类型
     */
    private __createSuccessResult;
    /**
     * 创建失败结果
     * @param authType 授权类型
     * @param failReason 失败原因
     */
    private __createFailResult;
    /**
     * 创建重定向的失败结果
     * @param authType 授权类型
     * @param redirectUrl 跳转地址
     */
    private __createRedirectErrorResult;
}

export declare class PlvBarrageModule extends ModuleBase {
    /** 当前创建的弹幕实例对象 */
    private __barrageTargets;
    /** 弹幕事件添加回调列表 */
    private __barrageAddCallback;
    private __barrageAddIntercept?;
    /** 弹幕字号双向映射表 */
    private __sizeMap;
    /** 弹幕速度双向映射表 */
    private __speedMap;
    /** 弹幕位置选项信息 */
    private __barrageLocationSetting;
    constructor(__watchCore: PolyvWatchCore);
    /**
     * 生成默认的弹幕设置
     * @version v1.2.0
     */
    static generateDefaultBarrageSetting(): BarrageSetting;
    /**
     * 获取弹幕设置
     *
     * 用于获取管理后台的弹幕设置信息。
     *
     * 从 v1.2.0 开始可以通过 `PlvBarrageModule.generateDefaultBarrageSetting()` 来获取默认配置
     *
     * @example
     * ```js
     * const barrageSetting = watchCore.barrage.getBarrageSetting();
     * console.log('弹幕功能开关', barrageSetting.barrageEnabled);
     * console.log('弹幕默认显示', barrageSetting.barrageDefaultShow);
     * ```
     */
    getBarrageSetting(): BarrageSetting;
    /**
     * 格式化弹幕消息
     * @param msg 弹幕消息
     */
    formatBarrageMsg(msg: string): string;
    /**
     * 设置弹幕
     * @api
     */
    setupBarrage(options: SetupBarrageOptions): BarrageTarget;
    /**
     * 销毁弹幕实例对象
     * @api
     * @param target 实例对象
     */
    destroyTarget(target: BarrageTarget): void;
    /**
     * 设置弹幕添加拦截器
     * @api
     * @param interceptFn 拦截方法，如果方法返回 true 则不会插入弹幕
     */
    setBarrageAddIntercept(interceptFn?: BarrageAddIntercept): void;
    /**
     * 设置弹幕添加事件回调
     * @api
     * @param callback 回调方法
     */
    setBarrageAddEventCallback(callback: BarrageAddCallback): void;
    /**
     * 移除弹幕添加事件回调
     * @api
     * @param callback 回调方法
     */
    removeBarrageAddEventCallback(callback: BarrageAddCallback): void;
    /**
     * 触发添加弹幕回调
     */
    private __callbackAddBarrage;
    /**
     * 筛选得到弹幕可用的聊天消息
     * */
    private __filterBarrageChatMsg;
    /** 处理聊天室事件 */
    private __onChatMessage;
    private __onSelfMessage;
    /** 回放对象改变时，清除当前显示的弹幕 */
    private __onCurrentPlaybackTargetChange;
    private __initBarrageLocationSetting;
    /**
     * 获取弹幕位置不同类型下的显示方向,百分比等详细信息
     */
    getBarrageLocationSetting(): BarrageLocationInfo[];
    /** 处理页面尺寸改变事件 */
    private __onResize;
    private __isListened;
    /**
     * 监听事件
     * @todo 看看是否需要拆成 socket-service 处理
     * */
    private __listenEvents;
    /** 移除聊天室事件监听 */
    private __removeListenEvents;
    destroy(): void;
}

/**
 * @class 频道基础模块
 * */
declare class PlvChannelBasicModule extends ModuleBase {
    /** 频道事件对象 */
    eventEmitter: EventEmitter<ChannelEventsRelations, ChannelEvents>;
    /**
     * 频道基础信息
     */
    private __channelBasicInfo;
    /**
     * 频道基础信息（英文）
     */
    private __enChannelBasicInfo;
    /**
     * 获取频道基础信息
     *
     * 根据语言类型获取频道基础信息（含英文配置），如：频道名称、频道介绍、主持人名称。
     * @param type 语言类型
     * @example
     * ```js
     * // 获取频道的基础信息
     * const cnBasicInfo = watchCore.channel.getChannelBasicInfo();
     * console.log('频道名称', cnBasicInfo.title);
     * console.log('频道介绍', cnBasicInfo.description);
     * console.log('主持人名称', cnBasicInfo.publisher);
     *
     * // 获取频道的英文基础信息
     * const enBasicInfo = watchCore.channel.getChannelBasicInfo('en');
     * console.log('英文频道名称', enBasicInfo.title);
     * ```
     */
    getChannelBasicInfo(type?: LanguageType): ChannelBasicInfo;
    /**
     * 设置频道详情
     * @param channelDetail 频道详情
     */
    protected _setupChannelBasicModule(channelDetail: ChannelDetail): void;
    protected _destroyChannelBasicStore(): void;
}

/**
 * 频道信息模块
 * @class
 */
declare class PlvChannelInfoModule extends PlvChannelBasicModule {
    /** 频道信息 */
    private __channelInfo;
    /**
     * 获取频道场景
     *
     * 用于判断频道类型，如是否为三分屏的频道，是否为研讨会的频道
     * @example
     * ```js
     * import { ChannelScene } from '@polyv/live-watch-sdk';
     * const scene = watchCore.channel.getChannelScene();
     * const isAloneChannel = scene === ChannelScene.Alone; // 普通直播频道
     * const isPptChannel = scene === ChannelScene.Ppt; // 三分屏频道
     * const isSeminarChannel = scene === ChannelScene.Seminar; // 研讨会频道
     * ```
     */
    getChannelScene(): ChannelScene;
    /**
     * 是否为研讨会的频道
     * @internal
     */
    get isSeminarChannel(): boolean;
    /** 轮训间隔信息 */
    protected _frequencyInfo: QueryFrequencyInfo;
    /** 渠道 id */
    private __promoteId?;
    /**
     * 获取渠道 id
     *
     * 通过后台设置的渠道进入观看页后，在创建观看页 SDK 实例时传入 `promoteId` 渠道号配置，可通过该方法获取当前观众的渠道 id，用作其他处理。
     * @example
     * ```js
     * import { createWatchCore } from '@polyv/live-watch-sdk';
     * const watchCore = createWatchCore({
     *   channelId: '频道号',
     *   promoteId: '渠道号',
     * });
     *
     * // 需要重新获取渠道号时
     * const promoteId = watchCore.channel.getPromoteId();
     * ```
     */
    getPromoteId(): string | undefined;
    /**
     * 设置渠道 id
     * @internal
     * @ignore
     */
    setPromoteId(promoteId: string): void;
    /**
     * 测试模式 token
     */
    private __testModeToken?;
    /**
     * 获取测试模式 token
     * @internal
     * @ignore
     */
    getTestModeToken(): string | undefined;
    /**
     * 设置测试模式 token
     * @internal
     * @ignore
     */
    setTestModeToken(testModeToken: string): void;
    /**
     * 获取频道号
     * @internal
     * @ignore
     */
    getChannelId(options?: GetChannelIdOptions): string;
    /**
     * @internal
     * @ignore
     */
    get isListenDoubleTransmitMain(): boolean;
    /**
     * 获取频道模块存储的信息
     * @internal
     * @ignore
     * */
    getChannelInfo(): ChannelModuleInfo;
    /**
     * 更新频道信息
     * @internal
     * @ignore
     */
    updateChannelInfo(info: Partial<ChannelModuleInfo>): void;
    /** 强行切换到回放 */
    private __forceChangePlaybackEnabled;
    /**
     * 设置直播结束是否强行切换到回放
     * @warn 从 v1.0.0 版本开始，不需要外部手动执行该方法，改为在 `watchCore.player.setupPlayer` 方法中设置 `autoChangePlayback` 传参为 true 即可
     * @version v0.7.0
     * @internal
     * @ignore
     */
    setForceChangePlaybackEnabled(enable: boolean): void;
    /**
     * 获取是否强行切换到回放
     * @version v0.7.0
     * @internal
     * @ignore
     */
    getForceChangePlaybackEnabled(): boolean;
    /**
     * 设置频道详情
     * @param channelDetail 频道详情
     */
    protected _setupChannelInfoModule(channelDetail: ChannelDetail): void;
    /**
     * 获取频道转播场景
     * @version v0.9.0
     * @internal
     * @ignore
     */
    getChannelTransmitType(): ChannelTransmitType;
    /**
     * 检查是否为直播测试模式
     * @param channelDetail 频道详情
     * @desc 开播端/助教页"测试模式"开关
     */
    private __checkLiveTestMode;
    /**
     * 当前在频道是否在测试模式
     * 测试模式下的频道，需要携带对应的 token 才能正常观看直播
     *
     * @version v1.0.0
     * @internal
     * @ignore
     * @warn 仅 SDK 内部模块使用
     */
    inTestMode(): boolean;
    /**
     * 获取"当前频道是否处于直播测试模式"
     * @version v0.5.1
     * @internal
     * @ignore
     */
    getLiveTestMode(): boolean;
    /**
     * 检查是否为测试模式
     * @param channelDetail 频道详情
     * @desc 后端内部配置
     */
    private __checkTestModeStatus;
    /**
     * 获取"当前频道是否处于测试模式"
     * @desc 后端处理该状态的逻辑和 {@link  __testModeToken } 关联
     * @internal
     * @ignore
     */
    getTestModeStatus(): boolean;
    /** 直播状态轮训定时器 */
    private __liveStatusTimerList;
    /**
     * 获取频道直播场次号
     *
     * 通过 `getCurrentSessionId` 方法获取当前频道的最新场次号。
     * @returns 最新场次号
     * @example
     * ```js
     * const currentSessionId = watchCore.channel.getCurrentSessionId();
     * console.log('频道最新场次号', currentSessionId);
     * ```
     */
    getCurrentSessionId(): string;
    /**
     * 初始化设置场次号
     */
    private __setupCurrentSessionId;
    /**
     * 设置当前最新的场次号
     * @internal
     * @ignore
     * @param sessionId 场次号
     */
    setCurrentSessionId(sessionId: string): void;
    /**
     * 获取新场次状态
     * @internal
     * @ignore
     */
    getNewSessionStatus(): LiveStatus;
    /**
     * 获取频道的直播流
     * @internal
     * @ignore
     * @param options 判断选项，默认：false
     */
    getChannelStream(options: GetChannelStreamOptions): string;
    /**
     * 设置直播流状态
     * @internal
     * @ignore
     */
    setStreamStatus(status: LiveStatus): void;
    /**
     * 获取频道直播状态
     *
     * 用于获取频道当前的直播状态，通过 {@link ChannelEvents.LiveStatusChange} 事件监听直播状态更改事件。
     * @example
     * ```js
     * import { LiveStatus } from '@polyv/live-watch-sdk';
     *
     * watchCore.channel.eventEmitter.on(ChannelEvents.LiveStatusChange, () => {
     *   const liveStatus = watchCore.channel.getLiveStatus();
     *   console.log('是否正在直播', liveStatus === LiveStatus.Live);
     * });
     * ```
     */
    getLiveStatus(): LiveStatus;
    /**
     * 设置频道直播状态
     * @internal
     * @ignore
     */
    setLiveStatus(liveStatus: LiveStatus): void;
    /**
     * 关闭直播状态轮训
     *
     * 需要和 `watchCore.channel.startLiveStatusPolling` 方法配合使用
     *
     * @param pollingId 轮训 id
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const pollingId = watchCore.channel.startLiveStatusPolling();
     * watchCore.channel.removeLiveStatusPolling(pollingId);
     * ```
     */
    removeLiveStatusPolling(pollingId: string): void;
    /**
     * 开始直播状态轮训
     *
     * 会根据后端配置，在条件允许的情况下进行直播状态轮询
     *
     * @param pollingId 轮训 id
     * @return 轮询标识位，可用作移除轮询的参数
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const pollingId = watchCore.channel.startLiveStatusPolling();
     * console.info('轮询标识位：', pollingId);
     * ```
     */
    startLiveStatusPolling(pollingId?: string, options?: {
        timeout: number;
        maxPollingCount: number;
    }): string;
    /**
     * 处理直播状态轮训回调
     */
    private __liveStatusPollingCallback;
    /**
     * 获取直播状态信息, 无缓存
     */
    private __getLiveStatusData;
    /**
     * 获取直播状态信息, 有5s缓存
     */
    private __getLiveStatusDataV2;
    /**
     * pageView 定时器
     */
    private __pvTimer?;
    /**
     * 获取观看页浏览次数
     *
     * 如果不需要轮询通机制来更新浏览次数，可调用 `getPageViewCount` 方法来重新获取观众进入页面时的浏览次数。
     *
     * @category 页面浏览次数
     * @example
     * ```js
     * const pageViewCount = await watchCore.channel.getPageViewCount();
     * console.log('页面浏览次数', pageViewCount);
     * ```
     */
    getPageViewCount(): number;
    /**
     * 请求接口获取观看页浏览次数(pageView)
     */
    private __fetchPageViewCount;
    /**
     * 开启观看页浏览次数请求轮询
     *
     * 用于开启观看页浏览次数接口请求的轮询，在触发回调后更新页面的浏览次数。
     *
     * 从 v1.2.0 开始在方法调用后立即回调一次
     *
     * @category 页面浏览次数
     * @param callback 回调函数，获取每次轮询的浏览次数
     * @example
     * ```ts
     * watchCore.channel.startPageViewPolling((pageViewCount: number) => {
     *   console.log('页面浏览次数更新：', pageViewCount);
     * });
     * ```
     */
    startPageViewPolling(callback?: (pageViewCount: number) => unknown): void;
    /**
     * 获取最新的观看页浏览次数
     *
     * @category 页面浏览次数
     * @version v1.2.0
     */
    getLatestPageView(): Promise<number>;
    /**
     * 停止观看页浏览次数请求轮询
     *
     * 当页面销毁或相关组件销毁时，调用 `stopPageViewPolling` 停止轮询器。
     *
     * @category 页面浏览次数
     * @example
     * ```js
     * // vue 代码
     * export default {
     *   // 组件销毁前停止定时器
     *   beforeDestroy() {
     *     watchCore.channel.stopPageViewPolling();
     *   }
     * };
     * ```
     */
    stopPageViewPolling(): void;
    protected _destroyChannelInfoModule(): void;
    /**
     * 获取频道的直播场景
     * @version v2.13.0
     */
    getNewScene(): ChannelNewScene;
}

/**
 * 频道模块
 * @class
 */
export declare class PlvChannelModule extends PlvChannelInfoModule {
    protected _watchCore: PolyvWatchCore;
    /** 模块事件绑定服务 */
    private __bindModuleEventServices;
    /**
     * 频道详情（基础）
     * */
    private __channelDetailBasic?;
    /**
     * 频道详情（用户信息）
     * */
    private __channelDetailViewer?;
    /**
     * 频道详情 （基础+用户信息）
     * */
    private __channelDetail?;
    /** 是否显示回放待生成文本 */
    private __showPlaybackWaitTextEnabled;
    constructor(_watchCore: PolyvWatchCore);
    /**
     * @internal
     * @ignore
     */
    updateAppConfig(appConfig: Partial<AppConfig>): void;
    /**
     * 重置频道详情(慎用)
     * @version v2.17.0
     */
    resetChannelDetail(): void;
    /**
     * 频道模块初始设置
     * @internal
     * @ignore
     */
    setup(): void;
    /**
     * 初始化唯一性登录验证轮询
     */
    private __initUniqueViewerSessionPolling;
    protected _listenSelfModuleEvents(): void;
    protected _unlistenSelfModuleEvents(): void;
    /**
     * 强制切换回放后的副作用处理
     */
    private __forceChangePlaybackEffectHandler;
    /**
     * 强制切换到回放状态
     */
    private __forceChangePlaybackStatus;
    /**
     * 获取 channelDetail，组合频道基础配置和观众信息
     * @internal
     * @ignore
     * @param check 检查 channelDetail 的存在
     * @throws 当 channelDetail 不存在时抛错
     */
    getChannelDetail(check?: true): ChannelDetail;
    /**
     * 获取 channelDetail，组合频道基础配置和观众信息
     * @internal
     * @ignore
     * @param check 无需检查 channelDetail 的存在
     */
    getChannelDetail(check: false): ChannelDetail | undefined;
    /**
     * 获取频道配置
     * @internal
     * @ignore
     * @param check 检查 channelConfig 的存在
     * @throws 当 channelDetail.channelConfig 不存在时抛错
     */
    getChannelConfig(check?: true): ChannelConfig;
    /**
     * 获取频道配置
     * @internal
     * @ignore
     * @param check 无需检查 channelConfig 的存在
     * @throws 当 channelDetail.channelConfig 不存在时抛错
     */
    getChannelConfig(check: false): ChannelConfig | undefined;
    /**
     * 通过 API 来获取频道详情（基础），和后端确认，只需要读取一次频道基础数据即可
     * @internal
     * @ignore
     */
    getChannelDetailBasic(): Promise<ChannelDetailBasic>;
    /**
     * 通过 API 来获取观众信息和观众相关的频道配置
     * @internal
     * @ignore
     */
    getViewerInfo(): Promise<ChannelDetailViewer>;
    /**
     * 通过 API 来获取观众信息和观众回放信息
     * @version v0.7.0
     * @internal
     * @ignore
     */
    getViewerPlaybackInfo(): Promise<ChannelDetailViewerPlaybackInfo>;
    /**
     * 合并频道详情
     * @param channelDetailBasic 基础频道详情
     * @param channelDetailViewer 用户频道详情
     */
    private __mergeChannelDetail;
    /**
     * 通过 API 来获取频道详情结果（总）
     * @internal
     * @ignore
     */
    setupChannelDetailResult(): Promise<ChannelDetailResult | null>;
    /**
     * 生成观看页地址
     * @param channelId 频道号
     * @example
     * ```js
     * const watchUrl = watchCore.channel.generateWatchUrl('频道号');
     * location.href = watchUrl;
     * ```
     */
    generateWatchUrl(channelId: string): string;
    /**
     * 获取当前频道的观看页地址
     *
     * 用于获取当前观看页的地址。
     * @example
     * ```js
     * const watchUrl = watchCore.channel.getChannelWatchUrl();
     * console.log('当前观看页的打开地址', watchUrl);
     * ```
     */
    getChannelWatchUrl(): string;
    /**
     * 获取推流信息
     *
     * 用于获取当前频道的最新推流信息，如流的尺寸、推流类型等。
     * @example
     * ```js
     * const pushInfo = await watchCore.channel.getPushInfo();
     * console.log('流宽度', pushInfo.resolutionWidth);
     * console.log('流高度', pushInfo.resolutionHeight);
     * console.log('推流类型', pushInfo.streamType);
     * ```
     */
    getPushInfo(): Promise<StreamPushInfo>;
    /**
     * 验证观众唯一性登录
     * @internal
     * @ignore
     */
    verifyViewerSession(): Promise<VerifyViewerSessionResult>;
    /** 唯一性登录轮询定时器 */
    private __viewerSessionTimer;
    /**
     * 开启唯一性登录轮询
     * @internal
     * @ignore
     */
    startViewerSessionPolling(): void;
    /**
     * 停止唯一性登录轮询
     * @internal
     * @ignore
     */
    stopViewerSessionPolling(): void;
    /**
     * 获取观看页设置
     *
     * 用于获取管理后台设置的观看页设置信息。
     * @example
     * ```js
     * const setting = watchCore.channel.getWatchSetting();
     * if (!setting.watchEnabled) { alert('当前观看页暂未开放'); }
     * if (isMobile && !setting.mobileWatchEnabled) { alert('暂不支持移动端观看'); }
     * ```
     */
    getWatchSetting(): ChannelWatchSetting;
    /**
     * 获取默认的频道页面广告设置
     * @version v1.2.0
     */
    static generateDefaultPageAdvertSetting(): ChannelAdvertSetting;
    /**
     * 获取频道页面广告设置
     *
     * 用于获取管理后台设置的页面广告设置信息。
     *
     * 从 v1.2.0 开始可以通过 `PlvChannelModule.generateDefaultPageAdvertSetting()` 来获取默认配置
     *
     * @example
     * ```js
     * const setting = watchCore.channel.getPageAdvertSetting();
     * console.log('页面广告开关：', setting.pageAdvertEnabled);
     * console.log('允许关闭页面广告：', setting.closeAdvertEnabled);
     * ```
     */
    getPageAdvertSetting(): ChannelAdvertSetting;
    /**
     * 获取频道页面广告列表
     *
     * 用于获取管理后台设置的页面广告列表。
     * @returns 广告列表
     * @example
     * ```js
     * const advertList = watchCore.channel.getPageAdvertList();
     * advertList.forEach((item, index) => {
     *   console.log('广告内容', index, item.content);
     *   console.log('广告类型', index, item.advertType); // PageAdvertType
     *   console.log('跳转地址', index, item.href);
     * });
     * ```
     */
    getPageAdvertList(): PageAdvertItem[];
    /**
     * 获取频道图标广告默认设置
     * @version v2.0.0
     */
    static generateDefaultImgAdvertSetting(): ChannelIconAdvertSetting;
    /**
     * 获取频道图标广告设置
     * @version v2.0.0
     * @example
     * ```js
     * const iconSetting = watchCore.channel.getImgAdvertSetting();
     * console.log('图标广告开关：', iconSetting.iconAdvertEnabled);
     * console.log('关闭按钮是否显示：', iconSetting.closeIconAdvertEnabled);
     * ```
     */
    getImgAdvertSetting(): ChannelIconAdvertSetting;
    /**
     * 获取频道图标广告列表
     * @version v2.0.0
     */
    getIconAdvertList(): IconAdvertItem[];
    /**
     * 获取频道页脚设置
     *
     * 用于获取管理后台的页脚信息。
     * @returns 页脚设置
     * @example
     * ```js
     * const footerSetting = watchCore.channel.getPageFooterSetting();
     * console.log('页脚开关：', footerSetting.footerEnabled);
     * console.log('页脚文案：', footerSetting.footerText);
     * console.log('页脚链接：', footerSetting.footerLink);
     * ```
     */
    getPageFooterSetting(): ChannelPageFooterSetting;
    /**
     * 获取频道关注设置
     *
     * 用于获取管理后台的关注设置信息。
     * @example
     * ```js
     * const setting = watchCore.channel.getFollowSetting();
     * console.log('关注开关：', setting.followEnabled);
     * console.log('入口文案：', setting.followEntrance);
     * console.log('二维码图片：', setting.followImage);
     * ```
     */
    getFollowSetting(): ChannelFollowSetting;
    /**
     * 获取推荐的多语言配置
     * @version v1.1.0
     */
    static getRecommendLangSetting(): ChannelLangSetting;
    /**
     * 获取平板电脑布局设置
     * 应用于识别为移动端的平板电脑应该显示移动端还是桌面端模版
     * @version v1.5.0
     */
    static getTabletLayoutSetting(): TabletLayoutSetting;
    /**
     * 获取频道多语言设置
     *
     * 用于获取后台的多语言设置信息。
     * @example
     * ```js
     * const setting = watchCore.channel.getLangSetting();
     * console.log('多语言开关：', setting.langSwitchEnabled);
     * console.log('双语界面开关：', setting.englishSettingEnabled);
     * console.log('是否跟随浏览器语言：', setting.isFollowBrowserLang);
     * console.log('默认的语言类型：', setting.defaultLangType);
     * ```
     */
    getLangSetting(): ChannelLangSetting;
    /**
     * 获取主讲信息
     * @category 主讲信息
     * @version v2.13.0
     */
    getAnchorInfo(): Promise<ChannelAnchorInfo | undefined>;
    /**
     * 获取主讲关联的频道列表
     * @category 主讲信息
     * @version v2.13.0
     */
    getAnchorChannelList(options?: GetAnchorChannelListParams): Promise<PageContent<AnchorChannelItem>>;
    /**
     * 获取频道播放模式
     * @internal
     * @ignore
     * @todo 补充文档
     * @warn
     */
    getChannelPlayMode(): ChannelPlayMode | undefined;
    /**
     * 生成默认的频道布局设置
     * @version v1.2.0
     */
    static generateDefaultLayoutSetting(): ChannelLayoutSetting;
    /**
     * 获取频道布局设置
     *
     * 用于获取管理后台的页面布局相关设置。
     * @example
     * ```js
     * const setting = watchCore.channel.getLayoutSetting();
     * console.log('三分屏主屏布局模式：', setting.mainScreenLayoutMode);
     * console.log('移动端引导页布局：', setting.mobileSplashLayout);
     * console.log('移动端观看页页布局：', setting.mobileWatchLayout);
     * ```
     */
    getLayoutSetting(): ChannelLayoutSetting;
    /**
     * 生成频道皮肤主题设置
     * @version v1.2.0
     */
    static generateDefaultThemeSetting(): ChannelThemeSetting;
    /**
     * 获取观看页主题样式配置
     *
     * 当 themeStyleType 为 {@link ChannelWatchThemeStyleType.Theme} 时，可以传入主题来获取相关的样式配置
     *
     * @version v2.14.0
     * @category 皮肤主题
     *
     * @warn
     * v1 春节皮肤地址 'https://s2.videocc.net/watch-theme/spring/v1/config.json'
     * v2 春节皮肤地址 'https://s2.videocc.net/watch-theme/spring/v2/config.json'
     * v2 黑镜皮肤地址 'https://s2.videocc.net/watch-theme/black-golden/v2/config.json'
     */
    getWatchThemeStyleConfig<T>(theme: string, opts?: {
        url?: string;
    }): Promise<T>;
    /**
     * 获取频道皮肤主题设置
     *
     * 用于获取管理后台的皮肤主题设置。
     *
     * 从 v1.2.0 开始可以通过 `PlvChannelModule.generateDefaultThemeSetting()` 来获取默认配置
     *
     * @category 皮肤主题
     *
     * @example
     *
     * ```js
     * const setting = watchCore.channel.getThemeSetting();
     * console.log('皮肤风格：', setting.pageSkin);
     * console.log('直播间图标：', setting.channelCoverImg);
     * ```
     */
    getThemeSetting(): ChannelThemeSetting;
    /**
     * 生成频道顶部引导条配置
     * @version v2.0.0
     */
    static generateDefaultTopGuideSetting(): ChannelTopGuideSetting;
    /**
     * 获取频道顶部引导条配置
     * @version v2.0.0
     * @category 其他开关
     */
    getTopGuideSetting(): ChannelTopGuideSetting;
    /**
     * 获取讲师信息
     *
     * 用于获取当前讲师/主讲的信息。
     * @example
     * ```js
     * const teacherInfo = watchCore.channel.getTeacherInfo();
     * console.log('讲师昵称', teacherInfo.nick);
     * console.log('讲师头像', teacherInfo.pic);
     * console.log('讲师头衔', teacherInfo.actor);
     * ```
     */
    getTeacherInfo(): TeacherInfoType;
    /**
     * 获取浏览次数设置信息
     *
     * 用于获取管理后台设置的页面浏览次数信息。
     *
     * @category 页面浏览次数
     * @example
     * ```js
     * const setting = watchCore.channel.getPageViewSetting();
     * console.log('页面浏览次数开关', setting.pvShowEnabled);
     * console.log('页面浏览次数', setting.pageViewCount);
     * console.log('移动端浏览次数位置', setting.mobilePvShowLocation);
     * ```
     */
    getPageViewSetting(): PageViewSetting;
    /**
     * 获取直播倒计时设置
     *
     * 用于获取后台设置的频道开始时间等设置信息。
     * @example
     * ```js
     * const setting = watchCore.channel.getCountdownSetting();
     * console.log('开始时间：', setting.liveStartTime);
     * console.log('回放下是否显示倒计时：', setting.playbackShowCountdownEnabled);
     * ```
     */
    getCountdownSetting(): ChannelCountdownSetting;
    /**
     * 获取音频模式类型
     * @internal
     * @ignore
     * @todo 补充文档
     */
    getAudioMode(): ChannelAudioMode;
    /**
     * 获取是否可以“切换音视频模式”
     * @internal
     * @ignore
     * @todo 补充文档
     */
    getAudioModeSwitchEnabled(): boolean;
    /**
     * 是否可以使用“泛域名”
     * @internal
     * @ignore
     * @todo 补充文档
     */
    getPolyvWatchDomainEnabled(): boolean;
    /**
     * 是否进行营销埋点
     * @version v0.6.0
     * @internal
     * @ignore
     */
    getWatchEventTrackEnabled(): boolean;
    /** 观看时长统计定时器 */
    private __watchDurationTimer?;
    /**
     * 结束观看时长统计轮询
     * @version v0.8.0
     */
    stopWatchDurationStatsPolling(): void;
    /**
     * 生成默认的观看时长设置
     * @version v2.7.0
     */
    static generateDefaultWatchDurationSetting(): ChannelWatchDurationSetting;
    /**
     * 获取观看时长设置
     * @version v0.8.0
     * */
    getWatchDurationSetting(): ChannelWatchDurationSetting;
    /**
     * 开始观看时长统计轮询
     * @desc 开始后会立即触发一次
     * @version v0.8.0
     */
    startWatchDurationStatsPolling(): void;
    /**
     * 获取观看时长统计数据
     */
    private __fetchWatchDurationStatsInfo;
    /**
     * 获取频道协议配置
     *
     * 可以获取在不同语言下的协议配置，主要用于授权类业务
     *
     * @version v0.10.0
     * @example
     * ```js
     * const agreementConfig = await watchCore.channel.getChannelAgreementConfig();
     * console.log('当前语言的协议配置', agreementConfig["zh_CN"]);
     * ```
     */
    getChannelAgreementConfig(): Promise<ChannelAgreementConfig>;
    /**
     * 获取频道流多轨配置
     *
     * 多轨配置和多线路不同，多线路获取的其实还是同个源，但是多轨是获取不同的推流来源
     *
     * @version v1.8.0
     */
    getChannelStreamTrackConfig(): ChannelStreamTrackConfig;
    /**
     * 获取在线列表开关
     * @version v1.8.0
     * @category 其他开关
     */
    getOnlineListEnabled(): boolean;
    /**
     * 获取管理员公告跑马灯开关
     * @version v2.0.0
     * @category 其他开关
     */
    getManagerBulletinMarqueeEnabled(): boolean;
    /**
     * 获取素材库开关
     * @internal
     * @ignore
     * @version v1.10.0
     */
    getMaterialEnabled(): boolean;
    /**
     * 生成默认的特效设置
     * @version v2.0.0
     */
    static generateDefaultEffectSetting(): ChannelEffectSetting;
    /**
     * 获取频道消息特效配置
     * @version v2.0.0
     * @category 其他开关
     */
    getEffectSetting(): ChannelEffectSetting;
    /**
     * 需要隐藏观众昵称
     * @version v2.0.0
     * @category 其他开关
     */
    needHideViewerNickname(): boolean;
    /**
     * 获取回放开关
     * @version v2.3.0
     * @category 其他开关
     */
    getEnablePlayback(): boolean;
    /**
     * 获取上一次推流时间
     * @version v2.3.0
     * @category 其他开关
     */
    getLastPushStreamTime(): number;
    /**
     * 获取直播新场次开关
     * @version v2.4.0
     * @category 其他开关
     */
    getTargetSessionEnabled(): boolean;
    /**
     * 获取直播介绍内容图片压缩开关
     * @version v2.5.0
     * @category 其他开关
     */
    getCompressImageEnabled(): boolean;
    /**
     * 获取频道用户分组配置
     * @version v2.16.0
     * @category 用户分组
     */
    getChannelViewerGroupConfig(): ChannelViewerGroupConfig;
    /**
     * 获取混合流渲染模式
     *
     * 混合流渲染模式，默认是填黑模式，如果需要剪裁模式，请在观看页设置中开启剪裁模式
     *
     * 填黑模式：
     * 这个模式下会严格保持源视频的宽高比进行等比缩放，渲染容器与源视频比例不一致会露出背景
     *
     * 剪裁模式：
     * 这个模式下会严格按照目的视频的宽高比对源视频剪裁之后再拉伸，并填满画布
     * @version v2.5.0
     * @category 其他开关
     */
    getMixStreamRenderMode(): MixStreamRenderMode;
    /**
     * 获取禁推流开关
     * @version v2.5.0
     * @category 其他开关
     * @deprecated 从 v2.7.0 版本废弃，请改用 {@link getPlaybackForbiddenEnabled }
     */
    getBanPushStream(): boolean;
    /**
     * 获取回放禁流开关
     * @version 2.7.0
     * @category 其他开关
     */
    getPlaybackForbiddenEnabled(): boolean;
    /**
     * 获取安卓增强全屏模式开关
     * @version v2.5.0
     * @category 其他开关
     */
    getAndroidFullScreenEnhancedEnabled(): boolean;
    /**
     * 获取低延迟智能播放开关
     * @version v2.5.0
     * @category 其他开关
     */
    getLowLatencyIntelligentPlayEnabled(): boolean;
    /**
     * 获取直播广场配置
     * @version v2.6.0
     * @category 其他开关
     */
    getLiveSquareConfig(): LiveSquare | undefined;
    /**
     * 获取频道场次列表
     * @category 直播新场次
     */
    getChannelSessionList(params?: GetChannelSessionListParams): Promise<PageContent<ChannelSessionDataItem>>;
    /**
     * 获取是否显示回放待生成文本开关
     * @version v2.9.0
     * @category 其他开关
     */
    getShowPlaybackWaitTextEnabled(): boolean;
    /**
     * 获取商品库横屏位置配置
     * @version v2.13.0
     * @category 其他开关
     */
    getProductEntryLandscapePosition(): string;
    /**
     * 获取小班课频道是否允许登录
     * @version v2.13.0
     * @category 其他开关
     */
    getSmallClassLoginEnabled(): Promise<boolean>;
    /**
     * 获取商品库图标配置
     * @version v2.14.0
     * @category 皮肤主题
     */
    getProductIconConfig(): ProductIconConfig | undefined;
    /**
     * @ignore
     */
    destroy(): void;
}

/**
 * @class 聊天室核心模块
 */
declare class PlvChatCoreModule extends ModuleBase {
    /** 聊天室事件对象 */
    eventEmitter: EventEmitter<ChatEventsRelations, ChatEvents>;
    /**
     * 聊天核心配置
     * @version v2.0.0
     */
    private __chatCoreConfig;
    /**
     * @internal
     * @ignore
     */
    getChatCoreConfig(): ChatCoreConfig;
    /**
     * @internal
     * @ignore
     */
    updateChatCoreConfig(config?: ChatCoreConfig): void;
    /** 聊天室 SDK 实例 */
    private __chatCore?;
    /** 聊天室 socket 实例 */
    socketTarget?: PolyvSocketPkgType.PolyvSocket;
    /** 聊天室 SDK 实例 */
    chatTarget?: PolyvChatPkgType.PolyvChat;
    constructor(_watchCore: PolyvWatchCore);
    protected _setChatCore(chatCore: Chat): void;
    /**
     * 安装 chatCore 模块
     */
    protected _setupChatCoreModule(): Promise<void>;
    /**
     * 获取聊天室 SDK 实例
     * @internal
     * @ignore
     * @param check 检查是否存在 chatCore
     * @throws 当 chatCore 未创建时抛错
     */
    getChatCore(check?: true): Chat;
    /**
     * 获取聊天室 SDK 实例
     * @internal
     * @ignore
     * @param check 无需检查 chatCore 是否存在
     */
    getChatCore(check?: false): Chat | undefined;
    /**
     * 获取聊天室 socket 实例
     * @param check 检查是否存在 socket
     * @throws 当 socket 未创建时抛错
     * @internal
     * @ignore
     */
    getSocket(check?: true): SocketIOClient.Socket;
    /**
     * 获取聊天室 socket 实例
     * @param check 无需检查 socket 是否存在
     */
    getSocket(check?: false): SocketIOClient.Socket | undefined;
    /**
     * 发送 socket
     * @internal
     * @ignore
     * @param type socket 类型
     * @param data 数据
     * @param parseCallback 是否 JSON.parse 回调
     */
    emitChatWs<C extends unknown[] = []>(type: SocketTypes, data: object, parseCallback?: boolean): Promise<C>;
    /**
     * 销毁核心
     */
    protected _destroyChatCore(): Promise<void>;
    /**
     * 销毁 chatCore 模块
     */
    protected _destroyChatCoreModule(): void;
}

/**
 * 聊天室模块
 * @class
 */
export declare class PlvChatModule extends PlvChatCoreModule {
    /**
     * 聊天历史消息是否加密
     */
    private __chatHistoryEncrypt;
    /** api 消息过滤器 */
    private __apiMsgFilter;
    /** api 场次消息过滤器 */
    private __apiSessionMsgFilter;
    /** sdk 消息过滤器 */
    private __sdkMsgFilter;
    /** 聊天消息重放逻辑服务 */
    private __chatMsgReplayLogicService;
    /**
     * 聊天室 Socket 监听服务
     */
    private __chatSocketService;
    private __chatTargetService;
    /**
     * 聊天室配置
     * @private
     */
    private __chatConfig?;
    /**
     * 评论上墙 服务
     */
    private __chatMsgSpeakTopService;
    /**
     * 获取聊天室配置
     * @version v0.4.0
     * @internal
     * @ignore
     */
    getChatConfig(): ChatConfig | undefined;
    /**
     * 获取 sdk 消息过滤器
     * @internal
     * @ignore
     */
    getSdkMsgFilter(): ChatMsgSdkFilter;
    /**
     * 设置聊天历史消息是否加密
     *
     * 仅 `getChatHistoryByTime` 方法支持加密返回
     *
     * @version v2.9.0
     * @category 获取聊天历史记录
     * @param chatHistoryEncrypt 聊天历史消息是否加密
     */
    setChatHistoryEncrypt(chatHistoryEncrypt: boolean): void;
    /**
     * 聊天室信息
     */
    private __chatInfo;
    /**
     * 更新聊天室信息
     * @internal
     * @ignore
     */
    updateChatInfo(info: Partial<ChatModuleInfo>): void;
    /**
     * 获取聊天室信息
     *
     * 与用户、聊天室有关的状态均存储在聊天室模块中，并通过 `getChatInfo` 获取聊天室状态信息。
     * @returns 聊天室状态信息
     * @example
     * ```js
     * const chatInfo = watchCore.chat.getChatInfo();
     * console.log('房间是否被关闭', chatInfo.chatRoomIsClosed);
     * console.log('当前用户是否被禁言', chatInfo.isShield);
     * ```
     */
    getChatInfo(): ChatModuleInfo;
    /**
     * 生成默认的聊天室设置
     * @version v1.2.0
     */
    static generateDefaultChatSetting(): ChatSetting;
    /**
     * 获取聊天室设置
     *
     * 从 v1.2.0 开始可以通过 `PlvChatModule.generateDefaultChatSetting()` 来获取默认配置
     *
     * 用于获取管理后台的聊天室设置信息。
     * @example
     * ```js
     * const setting = watchCore.chat.getChatSetting();
     * console.log('观看页聊天室开关', setting.watchChatEnabled);
     * console.log('是否显示翻译功能', setting.chatTranslateEnabled);
     * ```
     */
    getChatSetting(): ChatSetting;
    constructor(_watchCore: PolyvWatchCore);
    /**
     * 聊天室模块初始化设置
     * @internal
     * @ignore
     */
    setup(): void;
    /**
     * 创建聊天室 SDK
     * @internal
     * @ignore
     */
    createChat(): Promise<void>;
    /**
     * 安装聊天室 SDK，初始化 Socket
     * @internal
     * @ignore
     */
    setupChat(): Promise<void>;
    /**
     * socket 事件绑定钩子
     * @internal
     * @ignore
     * */
    bindSocketEvents(): void;
    /**
     * 创建聊天室 SDK
     */
    private __createChatSdk;
    private __createChatSdkV2;
    /**
     * 生成聊天室房间号
     * @internal
     * @ignore
     */
    private __generateChatRoomId;
    /**
     * 重新设置聊天室房间号
     * @version v0.9.0
     * @internal
     * @ignore
     */
    resetChatRoomId(): void;
    /**
     * 获取聊天室房间号
     * @internal
     * @ignore
     */
    getChatRoomId(options?: {
        /** 优先使用转播主频道Id */
        preferTransmitMain?: boolean;
        /** 忽略转播处理  */
        ignoreTransmit?: boolean;
    }): string;
    /**
     * 获取聊天室token
     * @internal
     * @ignore
     */
    getChatToken(): string | undefined;
    /**
     * 获取用户 IP
     * @internal
     * @ignore
     */
    getViewerIp(): string;
    /**
     * 获取当前观众的聊天室用户信息
     * @internal
     * @ignore
     */
    getCurrentChatMsgUserData(): ChatMessageUser;
    /**
     * 获取聊天历史消息
     *
     * @deprecated 从 v2.16.0 开始废弃
     * 通过 `getChatHistory` 方法获取频道下的聊天历史消息。
     * @category 获取聊天历史记录
     * @param options 获取选项
     * @example
     * ```js
     * // 获取 0 ～ 19 条消息
     * const historyData = await watchCore.chat.getChatHistory({
     *   start: 0,
     *   end: 19,
     * });
     * // 返回数据示例，类型为：ChatMsgType[]
     * [{
     *   id: '5191c230-c6c4-11ed-8c31-23e8ced55946',
     *   time: 1679278200247,
     *   msgSource: 'speak',
     *   content: '今天天气真好[呲牙][酷]',
     *   user: {
     *     userId: '18012345678',
     *     nick: '小明',
     *     pic: '头像地址',
     *   },
     * }]
     * ```
     */
    getChatHistory(options?: GetChatHistoryOptions): Promise<ChatMsgType[]>;
    /**
     * 根据场次号分页获取聊天历史消息
     *
     * 通过 `getChatHistoryBySessionId` 方法获取直播场次中的聊天历史记录
     * @category 获取聊天历史记录
     * @param options 获取选项
     * @example
     * ```js
     * // 指定的场次号
     * const sessionId = 'gksk8f2itb';
     * const result = await watchCore.chat.getChatHistoryBySessionId({
     *   sessionId,
     * });
     * console.log('当前页', result.pageNumber);
     * console.log('每页数量', result.pageSize);
     * console.log('总条目数', result.totalItems);
     * console.log('总页数', result.totalPages);
     * console.log('消息列表', result.contents); // ChatMsgType[]
     * ```
     */
    getChatHistoryBySessionId(options: GetChatHistoryBySessionIdOptions): Promise<PageContent<ChatMsgType>>;
    /**
     * 获取传入到后端接口的 exclude
     * @param exclude 排除类型数组
     * @param needValidate 是否需要校验
     */
    private __getHistoryByTimeExclude;
    /**
     * 根据时间戳获取聊天历史消息
     * @version v0.9.0
     * @param options 请求选项
     * @category 获取聊天历史记录
     * @returns 消息列表
     */
    getChatHistoryByTime(options: GetChatHistoryByTimeOptions): Promise<ChatMsgType[]>;
    /**
     * 获取实时的点赞数
     *
     * 收到用户点赞事件后可通过该方法获取实时点赞数，通过 {@link ChatEvents.ChatLikeCountChange} 事件监听点赞数改变。
     * @example
     * ```js
     * const realtimeLikes = watchCore.chat.getRealtimeLikes();
     * console.log('实时点赞数：', realtimeLikes);
     * ```
     */
    getRealtimeLikes(): number;
    /**
     * 发送点赞数
     * @param times 点赞数
     */
    sendLike(times: number): Promise<number>;
    /**
     * 发送情绪反馈
     * @param type 类型
     * @param count 数量
     * @example
     * ```js
     * import { EmotionalFeedbackType } from '@polyv/live-watch-sdk';
     * // 发送 5 个“明白了”
     * watchCore.chat.sendEmotionalFeedback(EmotionalFeedbackType.Yes, 5);
     * // 发送 5 个“没听懂”
     * watchCore.chat.sendEmotionalFeedback(EmotionalFeedbackType.No, 5);
     * ```
     */
    sendEmotionalFeedback(type: EmotionalFeedbackType, count: number): void;
    /**
     * 暂存聊天室观众信息
     * @internal
     * @ignore
     */
    temporarySaveUserMsg(): Promise<void>;
    /**
     * 发送文本消息
     *
     * 用于观众进行聊天发言，调用过程中会触发 {@link ChatEvents.ChatMessage} 聊天消息事件。
     * @category 发送聊天消息
     * @param options 发言参数
     * @returns 发送到服务器后的消息对象
     * @example
     * ```ts
     * import { ChatMsgQuoteOriginType, ChatMsgSpeakType } from '@polyv/live-watch-sdk';
     * // 发送的文本
     * const content = '今天天气真好[呲牙][酷]';
     * // 被回复的消息
     * const currentQuoteMsg: ChatMsgSpeakType | undefined = undefined;
     * // 发送消息
     * watchCore.chat.sendSpeakMsg({
     *   content,
     *   quoteMsg: currentQuoteMsg,
     * });
     * ```
     */
    sendSpeakMsg(options: SendSpeakMsgOptions): Promise<ChatMsgSpeakType>;
    /**
     * 发送图片消息
     *
     * 用于观众发送图片消息，调用过程中会触发 {@link ChatEvents.ChatMessage} 聊天消息事件。
     * @category 发送聊天消息
     * @param options 发送图片参数
     * @returns 发送到服务器后的图片消息对象
     * @example
     * ```js
     * import { uuidV4 } from '@polyv/utils/es/string';
     * // 图片 id
     * const imageId = uuidV4();
     * // 图片地址
     * const imageUrl = '发送到图片地址，需要带有协议';
     * // 图片地址
     * const size = { width: 200, height: 100 };
     * // 发送图片消息
     * watchCore.chat.sendImageMsg({ imageId, imageUrl, size });
     * ```
     */
    sendImageMsg(options: SendImageMsgOptions): Promise<ChatMsgImageType>;
    /**
     * 插入本地图片消息
     *
     * 用于观众发送图片消息，调用过程中会触发 {@link ChatEvents.ChatMessage} 聊天消息事件。
     * @category 发送聊天消息
     * @version v0.8.0
     * @internal
     * @ignore
     */
    insertLocalImageChatMsg(options: SendImageMsgOptions): ChatMsgImageType;
    /**
     * 直接发送图片消息
     *
     * 用于观众发送图片消息，调用过程中会触发 {@link ChatEvents.ReplaceChatMessage} 聊天消息事件。
     * @category 发送聊天消息
     * @version v0.8.0
     * @internal
     * @ignore
     * @returns 发送到服务器后的消息对象
     * */
    sendImageMsgDirectly(imageChatMsg: ChatMsgImageType): Promise<ChatMsgImageType>;
    /**
     * 发送表情图片消息
     *
     * 通过 `getEmotionImages` 方法获取表情图片列表后，通过列表项的 `id`、`url` 发送表情图片消息，调用过程中会触发 {@link ChatEvents.ChatMessage} 聊天消息事件。
     *
     * 开发者可通过 {@link getEmotionImages} 获取表情图片列表。
     * @category 发送聊天消息
     * @param options 发送表情图片参数
     * @returns 发送到服务器后的消息对象
     * @example
     * ```js
     * // 获取表情图片列表
     * const emotionImages = await watchCore.chat.getEmotionImages();
     * // 发送表情图片
     * const item = emotionImages[2];
     * watchCore.chat.sendEmotionImageMsg({ emotionId: item.id, emotionUrl: item.url });
     * ```
     */
    sendEmotionImageMsg(options: SendEmotionImageMsgOptions): Promise<ChatMsgEmotionType>;
    /**
     * 发送系统消息
     *
     * 用于发送系统消息到聊天区，注意该消息并不会发送到服务端，调用过程中会触发 {@link ChatEvents.ChatMessage} 聊天消息事件。
     * @category 发送聊天消息
     * @param content 消息内容
     * @example
     * ```js
     * watchCore.chat.sendSystemMsg('聊天室已关闭');
     * ```
     */
    sendSystemMsg(content: string, type?: string): void;
    /**
     * 发送自定义消息(客户端)
     *
     * 用于发送自定义消息(客户端)，调用过程中会触发 {@link ChatEvents.ChatMessage} 聊天消息事件，该事件返回的数据中会对应 {@link ChatMsgSource.CustomMessage} 的聊天消息数据
     * @category 发送聊天消息
     * @param options 自定义消息选项
     * @return 发送成功的自定义消息id
     * @version v0.10.0
     * @example
     * ```js
     * watchCore.chat.sendCustomMessage({ data: { test: '测试' } });
     * ```
     */
    sendCustomMessage<T extends object>(options: SendCustomMessageOptions<T>): Promise<string>;
    /**
     * 插入本地打赏消息
     *
     * 用于观众优先发送本地打赏消息，调用过程中会触发 {@link ChatEvents.ChatMessage} 聊天消息事件。
     *
     * 注意，插入本地打赏消息肯定为当前观众
     *
     * @category 发送聊天消息
     * @param options 打赏消息选项
     * @version v0.11.0
     */
    insertLocalRewardChatMsg(options: InsertLocalRewardChatMsgOptions): void;
    /**
     * 完整的消息文本记录对象
     */
    private __fullMessageRecord;
    /**
     * 获取超长消息的完整文本
     *
     * 讲师可发送超过 2000 字的文本消息，该消息为超长文本消息（通过 `chatMsg.isOverLength === true` 判断），`chat` 提供消息文本只会返回前 1000 字的消息字符串，如需展示完整的消息文本，可调用该方法获取。
     * @param id 聊天消息 id
     * @param chatMsg 聊天消息，在未超过服务端聊天文本长度或者请求异常时会使用聊天消息内容返回 [v0.11.0 新增]
     * @example
     * ```ts
     * import { ChatMsgSpeakType } from '@polyv/live-watch-sdk';
     *
     * async function getFullMessageText(chatMsg: ChatMsgSpeakType): Promise<string> {
     *   if (!chatMsg.isOverLength) {
     *     throw new Error('该消息非超长文本');
     *   }
     *
     *   const result = await watchCore.chat.getFullMessage(chatMsg.id, chatMsg);
     *   console.log('完整的文本', result);
     *   return result;
     * }
     * ```
     */
    getFullMessage(id: string, chatMsg?: ChatMsgSpeakType): Promise<string>;
    /** 在线用户列表定时器 */
    private __onlineUserListTimer?;
    /**
     * 开始在线用户列表轮询
     * @category 在线列表
     * @version v1.8.0
     * @description 每隔 1 分钟轮询在线用户列表，调用后会立即触发一次
     */
    startOnlineUserListPolling(): void;
    /**
     * 结束在线用户列表轮询
     * @category 在线列表
     * @version v1.8.0
     */
    stopOnlineUserListPolling(): void;
    /**
     * 获取在线用户列表新接口
     * @category 在线列表
     * @version v1.8.0
     * @example
     * ```js
     * const result = await watchCore.chat.getOnlineUserListNew();
     * console.log('在线列表：', result.userlist);
     * ```
     */
    getOnlineUserListNew(): Promise<UserListResult>;
    /**
     * 记录当前的在线人数
     */
    private __onlineUserCount;
    /**
     * 设置聊天室在线人数
     * @internal
     * @ignore
     * @param onlineUserCount 在线人数
     */
    setOnlineUserCount(onlineUserCount: number): void;
    /**
     * 获取聊天室的实时在线人数
     *
     * 通过 `getOnlineUserCount` 获取实时在线人数，{@link ChatEvents.OnlineUserCountChange} 事件监听聊天室在线人数的改变。
     * @category 在线列表
     * @returns 实时在线人数
     * @example
     * ```js
     * const onlineUserCount = watchCore.chat.getOnlineUserCount();
     * console.log('当前聊天室在线人数：', onlineUserCount);
     *
     * // 监听人数改变
     * watchCore.chat.eventEmitter.on(ChatEvents.OnlineUserCountChange, (data) => {
     *   console.log('在线人数改变：', data.onlineUserCount);
     * });
     * ```
     */
    getOnlineUserCount(): number;
    /**
     * 转换发言内容
     *
     * 通过 `parseSpeakContent` 将观众发言中的表情、链接转换成 html 元素。
     *
     * 转换顺序：parseLink > removeEmotion > parseEmotion > parseLineBreak
     * @param content 发言内容
     * @param options 转换选项
     * @returns 转换后的 html 字符
     * @example
     * ```js
     * // 转换链接
     * watchCore.chat.parseSpeakContent('这是我们的官网地址：https://www.polyv.net/', { parseLink: true });
     * // 转换后的字符串：这是我们的官网地址：<a target="_blank" rel="noopener" href="https://www.polyv.net/">https://www.polyv.net/</a>
     *
     * // 移除表情
     * watchCore.chat.parseSpeakContent('今天天气真好[呲牙]', { removeEmotion: true });
     * // 转换后的字符串：今天天气真好
     *
     * // 转换表情
     * watchCore.chat.parseSpeakContent('今天天气真好[呲牙]', { parseEmotion: true });
     * // 转换后的字符串：今天天气真好<img src="黄脸表情图片地址" alt="呲牙" class="plv-emotion-img" />
     *
     * // 将换行符转成 <br />
     * watchCore.chat.parseSpeakContent('这是一段文字\n这是另一段文字', { parseLineBreak: true });
     * // 转换后的字符串：这是一段文字<br />这是另一段文字
     * ```
     */
    parseSpeakContent(content: string, options?: ParseOptions): string;
    /**
     * 获取聊天消息重放历史数据
     *
     * 通过 `getChatMsgReplayHistoryList` 来获取聊天消息重放的历史数据
     * @version v0.3.0
     * @param options
     * @returns 聊天消息重放历史数据
     * @example
     * ```ts
     * import { ChatReplayRequestHistoryMode } from "@polyv/live-watch-sdk"
     * const data = await watchCore.chat.getChatMsgReplayHistoryList({
     *    mode: ChatReplayRequestHistoryMode.Init,
     *    count: 20
     * })
     * ```
     */
    getChatMsgReplayHistoryList({ mode, replayMsg, count, }: {
        /** 聊天重放请求历史数据模式  */
        mode: ChatReplayRequestHistoryMode;
        /** 根据指定的模式传入对应的重放消息，比如需要加载旧数据，则传入当前聊天数据中的第一条消息 */
        replayMsg?: ChatReplayMsgType;
        /** 聊天数量，限制最大为 60 */
        count: number;
    }): Promise<ChatReplayMsgType[]>;
    /**
     * 处理聊天消息重放
     *
     * 外部使用时，需要结合观看页 SDK 的 {@link PlayerEvents.TimeUpdate} 事件回调来一起使用，使用过程中，可以通过 {@link ChatEvents.ChatMessage}` 事件来获取重放的消息
     * 由于回放时可以通过播放器进度条快速跳转，此时可以通过 {@link ChatEvents.ChatMsgReplayReload} 事件来监听是否需要重新加载聊天室数据
     * @version v0.3.0
     * @desc 从 v2.0.0 开始，处理聊天消息重放的时候，会根据配置自动处理卡片推送等其他聊天互动重放
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.ChatMessage, ({ chatMsg })=> {
     *    console.info(chatMsg);
     * })
     *
     * watchCore.chat.eventEmitter.on(ChatEvents.ChatMsgReplayReload, ()=> {
     *    console.info("重新加载聊天室数据");
     * })
     *
     * watchCore.player.eventEmitter.on(PlayerEvents.TimeUpdate, params => {
     *    watchCore.chat.processChatMsgReplay(params);
     * });
     *
     * ```
     */
    processChatMsgReplay(params: PlayerEventsRelations[PlayerEvents.TimeUpdate]): void;
    /**
     * 初始化聊天消息重放
     *
     * @version v0.3.0
     * 该方法需要在 `setChatMsgReplayPlaybackTarget` 之后去执行，聊天室模块才能正常地去初始化聊天重放记录，使用过程中，会回调 {@link ChatEvents.ChatMsgReplayStatusChange} 事件
     * @example
     * ```js
     * watchCore.chat.eventEmitter.on(ChatEvents.ChatMsgReplayStatusChange, ({ status }) => {
     *   console.info(status)
     * }
     *
     * // 需要先执行 setChatMsgReplayPlaybackTarget 方法
     * await watchCore.chat.initChatMsgReplay()
     * ```
     */
    initChatMsgReplay(): Promise<void>;
    /**
     * 添加聊天重放本地缓存插件
     *
     * 为了能够减少对聊天室接口的请求，聊天室模块在实现回放功能时，支持通过添加缓存插件，后续读取聊天重放记录时，优先从缓存中读取。
     *
     * 注意插件只会添加一次，添加完成后再添加不会生效，建议在 `initChatMsgReplay` 方法调用之前添加插件
     * @version v0.3.0
     * @warn 后续不推荐客户使用，直接使用聊天重放的 CDN 缓存，只是仍保留该方法，不对外同步该方法文档
     * @example
     * ```js
     * // 以 localforage 库为例
     * import localForage from 'localforage'
     * watchCore.chat.addChatMsgReplayCachePlugin({
     *    getItem: localForage.getItem,
     *    setItem: localForage.setItem,
     *    removeItem: localForage.removeItem,
     *    iterate: localForage.iterate,
     *  });
     * ```
     */
    addChatMsgReplayCachePlugin(localCache: ChatMsgReplayCachePluginType): void;
    /**
     * 使用重发机制发送聊天消息
     *
     * 此方法允许通过重发机制发送聊天消息，支持发言、图片和表情消息类型。
     * 根据提供的选项，可以决定是否仅发送本地消息或强制发送。
     *
     */
    private __emitChatMessageWithResend;
    /**
     * 通过重发机制替换聊天消息
     *
     */
    private __emitReplaceMessageWithResend;
    /**
     * 根据id 移除聊天消息
     * @category 发送聊天消息
     * @version v1.2.0
     */
    removeChatMsg(id: string): void;
    /**
     * 根据id，替换对应的聊天内容
     * @category 发送聊天消息
     * @version v1.2.0
     */
    replaceChatMsg(id: string, chatMsg: ChatMsgType): void;
    /**
     * 获取评论上墙数据
     * @category 消息/评论上墙
     * @version v1.5.0
     */
    getSpeakTopInfo(): ChatMsgSpeakTopType | undefined;
    /**
     * 设置评论上墙数据
     * @category 消息/评论上墙
     * @version v1.5.0
     */
    setSpeakTop(data: ChatMsgSpeakTopType | SliceIdSpeakTop): void;
    /**
     * 取消评论上墙
     * @category 消息/评论上墙
     * @version v1.5.0
     */
    cancelSpeakTop(): void;
    /**
     * 获取聊天区通知文本
     */
    getChatCustomIntroductionText(): string;
    /**
     * 获取频道文件列表
     * @category 消息/文件
     * @version v2.6.0
     * */
    getChannelFileList(params: GetChannelFileListParams): Promise<GetChannelFileListResponse>;
    /**
     * 销毁聊天室 SDK 实例
     * @version v2.11.0
     * @internal
     * @ignore
     */
    destroyChat(): Promise<void>;
    /**
     * 销毁聊天室模块
     * @ignore
     */
    destroy(): Promise<void>;
}

/**
 * 连麦模块
 * @class
 */
export declare class PlvConnectMicModule extends ModuleBase {
    /**
     * 连麦模块事件触发器
     */
    eventEmitter: EventEmitter<ConnectMicEventsRelations, ConnectMicEvents>;
    /**
     * 连麦 socket 服务
     */
    private __connectMicSocketService;
    /**
     * 镜像状态 localStorage key
     */
    private static readonly __mirrorStorageKey;
    /**
     * 生成默认的连麦信息
     * @version v1.2.0
     */
    static generateDefaultConnectMicInfo: () => ConnectMicStoreInfo;
    /**
     * 连麦信息
     */
    private __connectMicInfo;
    /**
     * 连麦信息
     */
    private __tempConnectMicInfo;
    /**
     * 举手超时定时器
     */
    private __applyTimeOut;
    private __autoConnectStatus;
    private __updateTempConnectMicInfo;
    /**
     * 更新连麦信息
     * @internal
     * @ignore
     */
    updateConnectMicInfo(info: Partial<ConnectMicStoreInfo>): void;
    /**
     * 获取连麦信息
     *
     * 连麦模块的状态，数据均通过 `connectMicInfo` 保存，开发者可通过 `getConnectMicInfo` 方法获取连麦信息。
     *
     * PS：通过 {@link ConnectMicEvents.ConnectMicInfoChange} 事件监听连麦事件改变。
     * @example
     * ```js
     * const info = watchCore.connectMic.getConnectMicInfo();
     * console.log('当前是否支持连麦功能', data.supportConnectMic);
     * console.log('当前是否开启连麦', data.openMicStatus);
     * ```
     */
    getConnectMicInfo(): ConnectMicStoreInfo;
    /**
     * 判断连麦状态是否处于连麦中
     *
     * 通过 `isConnectMicing` 判断用户或传入的状态是否处于连麦中（{@link ConnectMicStatus.Publishing} or {@link ConnectMicStatus.Connected}）。
     * @param status 连麦状态，不传则用当前状态
     * @returns 是否连麦中
     * @example
     * ```js
     * const res = watchCore.connectMic.isConnectMicing();
     * if (res) {
     *   console.log('用户连麦中');
     * } else {
     *   console.log('用户没有连麦');
     * }
     * ```
     */
    isConnectMicing(status?: ConnectMicStatus): boolean;
    /**
     * 网络状态工具
     */
    private __networkUtil;
    /**
     * 生成默认的连麦网络信息
     * @version v1.2.0
     */
    static generateDefaultNetworkInfo: () => ConnectMicNetworkInfo;
    /**
     * 连麦网络信息
     */
    private __networkInfo;
    /**
     * 更新网络信息
     * @internal
     * @ignore
     */
    updateNetworkInfo(info: Partial<ConnectMicNetworkInfo>): void;
    /**
     * 获取连麦网络信息
     * @returns 连麦网络信息
     * @example
     * ```js
     * const network = watchCore.connectMic.getNetworkInfo();
     * console.log('推流网络状态', network.uplinkNetworkStatus);
     * console.log('拉流网络状态', network.downlinkNetworkStatus);
     * ```
     */
    getNetworkInfo(): ConnectMicNetworkInfo;
    /**
     * @internal
     * @ignore
     * */
    bindSocketEvents(): void;
    /**
     * 设置连麦状态
     */
    private __setConnectMicStatus;
    /**
     * 设置前后摄像头状态
     */
    private __setFacingModeStatus;
    /**
     * 切换前后摄像头
     * @version v2.6.0
     * @example
     * ```js
     * watchCore.connectMic.changeFacingMode(FacingMode.Environment);
     * ```
     */
    changeFacingMode(
    /** 摄像头模式 */
    facingMode: FacingMode): void;
    /**
     * 设置邀请状态
     */
    private __setInviteStatus;
    /**
     * 连麦用户列表
     */
    private __connectMicList;
    /**
     * 获取连麦列表
     *
     * 观众观看连麦用户流方式：
     * - 当观众未连麦时，以混流的方式观看；
     * - 当观众连麦后，以 RTC 流观看；
     *
     * 当观众上麦或连麦用户流加入后触发 {@link ConnectMicEvents.ConnectMicListChange} 事件，开发者通过事件的 `connectMicList` 或 `getConnectMicList` 方法获取连麦用户列表。
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.ConnectMicListChange, () => {
     *   const connectMicList = watchCore.connectMic.getConnectMicList();
     *   console.log('连麦用户列表', connectMicList);
     * });
     * ```
     */
    getConnectMicList(): ConnectMicItem[];
    /**
     * 插入连麦列表
     * @internal
     * @ignore
     * @param micItem 连麦用户对象
     */
    pushMicItem(micItem: ConnectMicItem): void;
    /**
     * 移除连麦列表
     * @internal
     * @ignore
     * @param streamId 流 id
     */
    removeMicItem(streamId: string): void;
    /**
     * 清空连麦列表
     * @internal
     * @ignore
     */
    clearMicItem(): void;
    /**
     * rtc 实例
     */
    private __rtcInstance?;
    /**
     * 检查 rtc 是否初始化完成
     * @version v1.0.0
     * @internal
     * @ignore
     */
    checkRtcInited(): boolean;
    /**
     * 获取 rtc 实例
     * @param check 是否检查存在
     */
    private __getRtcInstance;
    /**
     * 获取 rtc 缩略类型
     * @param rtcType rtc 类型
     */
    private __getRtcAbridgeType;
    constructor(_watchCore: PolyvWatchCore);
    /**
     * @internal
     * @ignore
     */
    updateAppConfig(appConfig: AppConfig): void;
    /**
     * 是否支持连麦功能
     *
     * 用于判断当前环境是否支持连麦功能。
     * @example
     * ```js
     * const result = watchCore.connectMic.supportConnectMic();
     * console.log('是否支持连麦：', result.support ? '支持' : '不支持');
     * ```
     */
    supportConnectMic(): SupportResult;
    /**
     * 重置连麦支持状态
     * @version v0.9.0
     * @description 在重建播放器时需要重新设置支持状态
     * @internal
     * @ignore
     */
    resetSupportConnectMic(): void;
    /**
     * 是否为小班课场景
     * @returns
     */
    private __isSmallClass;
    /**
     * 获取小班课统计参数
     * @private
     */
    private __getClassStatConfig;
    /**
     * 设置连麦
     *
     * 观看页 SDK 默认不会设置连麦功能，如果需要连麦功能，开发者需要手动设置连麦功能，设置完成后即可调用连麦模块的 Api。
     * @returns 设置结果
     * @example
     * ```js
     * // 设置连麦功能
     * const result = await watchCore.connectMic.setupConnectMic();
     *
     * if (result.success) {
     *   // 打开设备设置
     *   watchCore.connectMic.openDeviceSetting();
     * } else {
     *   console.log('设置失败', result.failReason);
     * }
     * ```
     */
    setupConnectMic(): Promise<ConnectMicResult>;
    /**
     * 从 localStorage 加载镜像状态
     * @private
     */
    private __loadMirrorStatusFromStorage;
    /**
     * 以观众模式加入连麦房间, 仅订阅讲师流，不推本地流
     *
     * 在小班课场景下，观众可以通过此方法加入房间并观看讲师的流。
     * 此方法仅在小班课场景下有效，且连麦已初始化（setupConnectMic）后才能调用。
     * @category 小班课场景连麦
     * @returns 加入结果
     * @version v2.13.0
     * ```
     */
    joinAsAudience(): Promise<joinAsAudienceResult>;
    /**
     * 离开观众模式
     * @category 小班课场景连麦
     * @version v2.13.0
     * ```
     */
    leaveAudience(): Promise<void>;
    /**
     * 小班课场景停止统计
     * @category 小班课场景连麦
     * @version v2.13.0
     */
    stopSmallClassStat(): void;
    /**
     * 当前是否为观众模式
     * @category 小班课场景连麦
     * @version v2.13.0
     */
    isAudienceModeJoined(): boolean;
    /**
     * 切换镜像开关状态
     *
     * 通过 `toggleMirror` 方法可以切换本地连麦流的镜像状态。开启镜像后，本地流画面会水平翻转。
     * @param enabled 是否开启镜像，不传则切换当前状态
     * @version v2.10.0
     * @example
     * ```js
     * // 开启镜像
     * watchCore.connectMic.toggleMirror(true);
     *
     * // 关闭镜像
     * watchCore.connectMic.toggleMirror(false);
     *
     * // 切换镜像状态
     * watchCore.connectMic.toggleMirror();
     * ```
     */
    toggleMirror(enabled?: boolean): void;
    /**
     * 获取镜像状态
     *
     * 获取当前连麦流的镜像状态。
     * @returns 是否开启镜像
     * @version v2.10.0
     * @example
     * ```js
     * const mirrorEnabled = watchCore.connectMic.getMirrorEnabled();
     * console.log('镜像状态：', mirrorEnabled ? '开启' : '关闭');
     * ```
     */
    getMirrorEnabled(): boolean;
    private __listenLiveStatusChange;
    private __forceSyncConnectMicInfo;
    private __onCurrentSetNick;
    private __bindModuleEvents;
    private __unbindModuleEvents;
    /**
     * 监听连麦事件
     */
    private __bindRtcEvents;
    /**
     * 触发邀请上麦流程
     * @private
     */
    private __triggerInviting;
    /**
     * 打开设备设置界面
     *
     * 连麦模块提供内置的设备设置界面，通过 `openDeviceSetting` 方法打开设备设置界面，用于切换摄像头、麦克风设备等操作，当需要关闭时可调用 {@link closeDeviceSetting} 进行关闭。
     * @example
     * ```js
     * watchCore.connectMic.openDeviceSetting();
     * ```
     */
    openDeviceSetting(): void;
    /**
     * 关闭设备设置界面
     * @example
     * ```js
     * watchCore.connectMic.closeDeviceSetting();
     * ```
     */
    closeDeviceSetting(): void;
    /**
     * 打开邀请上麦界面
     *
     * 连麦模块提供内置的邀请上麦界面，当监听到 {@link ConnectMicEvents.InviteConnectMic} 讲师邀请上麦事件后，通过 `openInviting` 方法打开邀请上麦界面，需要关闭时可调用 {@link closeInviting} 进行关闭。
     *
     * PS: 观众点击同意时，可能因连麦人数到达上限而连麦失败，通过 {@link ConnectMicEvents.ConnectMicOverLimit} 事件监听并页面提示
     * @example
     * ```js
     * import { ConnectMicEvents } from '@polyv/live-watch-sdk';
     *
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.InviteConnectMic, () => {
     *   // 打开邀请连麦窗口
     *   watchCore.connectMic.openInviting();
     * });
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.ConnectMicOverLimit, () => {
     *   toast.error('连麦失败，连麦人数已到达上限');
     * });
     * ```
     */
    openInviting(): void;
    /**
     * 关闭邀请上麦界面
     * @example
     * ```js
     * watchCore.connectMic.closeInviting();
     * ```
     */
    closeInviting(): void;
    /**
     * 接受讲师上麦邀请
     *
     * 用于在自定义邀请上麦 UI 中调用，触发后等同于 SDK 内置邀请窗口的"同意"操作。
     * @version v2.17.0
     * @example
     * ```js
     * watchCore.connectMic.acceptInvite();
     * ```
     */
    acceptInvite(): void;
    /**
     * 拒绝讲师上麦邀请
     *
     * 用于在自定义邀请上麦 UI 中调用，触发后等同于 SDK 内置邀请窗口的"拒绝"操作。
     * @version v2.17.0
     * @example
     * ```js
     * watchCore.connectMic.refuseInvite();
     * ```
     */
    refuseInvite(): void;
    /**
     * 获取邀请上麦倒计时
     *
     * 返回当前邀请上麦的剩余时间和总时间，可在 {@link ConnectMicEvents.InviteCountDown} 事件中使用。
     * @version v2.17.0
     * @example
     * ```js
     * const { remain, total } = watchCore.connectMic.getInviteCountDown();
     * console.log(`剩余 ${remain}s / 总 ${total}s`);
     * ```
     */
    getInviteCountDown(): InviteCountDownData;
    /**
     * 开启本地预览
     *
     * 用于在连麦面板中预览本地摄像头，未连麦时调用，连麦中无需预览。
     * @example
     * @version v2.17.0
     * ```js
     * await watchCore.connectMic.startPreview({ videoEl: el, video: true });
     * ```
     */
    startPreview(config: PreviewConfig): Promise<PreviewHandle>;
    /**
     * 停止本地预览
     * @version v2.17.0
     * @example
     * ```js
     * watchCore.connectMic.stopPreview();
     * ```
     */
    stopPreview(): void;
    /**
     * 是否正在本地预览
     * @version v2.17.0
     */
    isPreviewing(): boolean;
    /**
     * 获取本地预览的当前音量（0~1）
     *
     * 仅在预览中可用；非预览态返回 0。
     * @version v2.17.0
     */
    getPreviewVolume(): number;
    /**
     * 获取当前本地音视频静音状态
     *
     * 返回 `{ video, audio }`，true 表示已关闭/静音。未连麦（预览阶段）时返回设备预设值，已连麦时返回底层推流实时状态。
     * @version v2.17.0
     */
    getLocalMuteStatus(): {
        video: boolean;
        audio: boolean;
    };
    /**
     * 预设/调整本地音视频开关
     *
     * 未推流时仅写入预设值，`acceptInvite` / `publish` 后生效；已推流时等价于调用 enable/disable 对应轨道。
     * @version v2.17.0
     * @param option `{ video?: boolean; audio?: boolean }`，true 表示关闭/静音
     */
    setLocalMuteStatus(option: {
        video?: boolean;
        audio?: boolean;
    }): void;
    /** 是否正在申请中，防止二次触发 */
    private __applyPromise?;
    /**
     * 观众申请连麦
     *
     * 当讲师/主讲开启连麦功能后，用户即可申请连麦，开发者可调用 `applyConnectMic` 方法申请连麦，在申请时可调用 {@link cancelApplyConnectMic} 取消连麦申请。
     *
     * PS: 通过 {@link ConnectMicEvents.AllowConnectMicApply} 监听连麦申请通过
     * @example
     * ```js
     * import { ConnectMicError, ConnectMicEvents } from '@polyv/live-watch-sdk';
     *
     * // 申请连麦
     * async function applyConnectMic() {
     *   const result = await watchCore.connectMic.applyConnectMic();
     *   if (result.success) {
     *     toast.success('连麦申请成功！请等待主讲同意');
     *     const info = watchCore.connectMic.getConnectMicInfo();
     *     console.log('当前连麦状态：', info.connectMicStatus); // ConnectMicStatus.Applying
     *     return;
     *   }
     *
     *   if (result.failReason === ConnectMicError.GetDevicePermissionFail) {
     *     toast.error('连麦申请失败！未获取设备权限');
     *   }
     * }
     *
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.AllowConnectMicApply, () => {
     *   toast.success('讲师已通过你的连麦申请');
     * });
     * ```
     */
    applyConnectMic(): Promise<ConnectMicResult>;
    private __clearApplyTimeOut;
    /**
     * 申请连麦获取设备授权后触发
     * 注意：授权后部分ios快直播画面正常，声音消失。无论授权成功或失败，均需要再次播放解决
     */
    private __resumeAfterDeviceDetection;
    /**
     * 取消连麦申请
     *
     * 当观众申请连麦后，调用 `cancelApplyConnectMic` 即可取消连麦申请。
     * @example
     * ```js
     * watchCore.connectMic.cancelApplyConnectMic();
     *
     * const info = watchCore.connectMic.getConnectMicInfo();
     * console.log('当前连麦状态：', info.connectMicStatus); // ConnectMicStatus.NotConnect
     * ```
     */
    cancelApplyConnectMic(): void;
    /**
     * 推送本地连麦流
     *
     * 讲师通过连麦申请后，通过 `publishLocalStream` 进行连麦流推送，注意该方法需要在 {@link ConnectMicEvents.LocalStreamInited} 事件触发后调用。
     *
     * 推流成功后将触发 {@link ConnectMicEvents.PublishStreamSuccess} 事件。
     *
     * 建议通过连麦用户节点 {@link ConnectMicItem.publishStream} 方法进行推送。
     * @param options 推流参数
     * @example
     * ```js
     * watchCore.connectMic.eventEmitter.on(ConnectMicEvents.LocalStreamInited, () => {
     *   watchCore.connectMic.publishLocalStream({
     *     element: 'NodeElement',
     *   });
     * });
     * ```
     */
    publishLocalStream(options: PublishStreamOptions): Promise<ConnectMicResult>;
    /**
     * 结束连麦
     *
     * 当讲师通过观众的连麦申请并连麦成功后，通过 `endConnectMic` 可手动结束观众的连麦。
     *
     * PS：通过 {@link ConnectMicEvents.LeaveConnectMicSuccess} 监听离开成功。
     * @example
     * ```js
     * // 结束连麦
     * watchCore.connectMic.endConnectMic();
     *
     * watchCore.connectMic.eventEmitter(ConnectMicEvents.LeaveConnectMicSuccess, () => {
     *   toast.success('结束连麦成功');
     *   const info = watchCore.connectMic.getConnectMicInfo();
     *   console.log('当前连麦状态：', info.connectMicStatus); // ConnectMicStatus.NotConnect
     * });
     * ```
     */
    endConnectMic(): void;
    /**
     * 开启本地摄像头
     *
     * 通过 `enabledVideo` 方法开启本地摄像头，可通过 {@link ConnectMicEvents.LocalVideoMuteChange} 事件监听本地摄像头的开关。
     * @example
     * ```js
     * // 开启本地摄像头
     * watchCore.connectMic.enabledVideo();
     * ```
     */
    enabledVideo(): void;
    /**
     * 关闭本地摄像头
     *
     * 通过 `disabledVideo` 方法关闭本地摄像头，可通过 {@link ConnectMicEvents.LocalVideoMuteChange} 事件监听本地摄像头的开关。
     * @example
     * ```js
     * // 关闭本地摄像头
     * watchCore.connectMic.disabledVideo();
     * ```
     */
    disabledVideo(): void;
    /**
     * 开启本地麦克风
     *
     * 通过 `enabledAudio` 方法开启本地麦克风，可通过 {@link ConnectMicEvents.LocalAudioMuteChange} 事件监听本地麦克风的开关。
     * @example
     * ```js
     * // 开启本地麦克风
     * watchCore.connectMic.enabledAudio();
     * ```
     */
    enabledAudio(): void;
    /**
     * 关闭本地麦克风
     *
     * 通过 `disabledAudio` 方法关闭本地麦克风，可通过 {@link ConnectMicEvents.LocalAudioMuteChange} 事件监听本地麦克风的开关。
     * @example
     * ```js
     * // 关闭本地麦克风
     * watchCore.connectMic.disabledAudio();
     * ```
     */
    disabledAudio(): void;
    /**
     * 生成默认的屏幕共享信息
     * @version v1.2.0
     */
    static generateDefaultScreenShareInfo: () => ScreenShareInfo;
    /**
     * 屏幕共享信息
     */
    private __screenShareInfo;
    /**
     * 更新屏幕共享信息
     * @internal
     * @ignore
     * @param info 屏幕共享信息
     */
    updateScreenShareInfo(info: Partial<ScreenShareInfo>): void;
    /**
     * 获取屏幕共享信息
     * @returns 屏幕共享信息
     * @example
     * ```js
     * const screenShareInfo = watchCore.connectMic.getScreenShareInfo();
     * console.log('是否支持屏幕共享', screenShareInfo.supportScreenShare);
     * console.log('正在屏幕共享中', screenShareInfo.isScreenSharing);
     * ```
     */
    getScreenShareInfo(): ScreenShareInfo;
    /**
     * 设置屏幕共享配置
     *
     * 通过 `setScreenShareConfig` 设置屏幕共享配置，注意屏幕共享期间无法调用该方法进行屏幕共享设置。
     * @param config 屏幕共享配置
     * @returns 设置结果
     * @example
     * ```js
     * import { ScreenShareMode } from '@polyv/live-watch-sdk';
     *
     * const result = await watchCore.connectMic.setScreenShareConfig({
     *   // 共享模式：动态画面为主
     *   screenShareMode: ScreenShareMode.Motion,
     *   // 开启混音
     *   audioMixEnabled: true,
     * });
     *
     * if (result.success) {
     *   console.log('设置成功');
     * }
     * ```
     */
    setScreenShareConfig(config?: ScreenShareConfig): ScreenShareResult;
    /**
     * 开始屏幕共享
     *
     * 通过 `startScreenShare` 开始屏幕共享，通过 {@link ConnectMicEvents.ScreenShareStart} 事件监听屏幕共享开始，注意开始前浏览器需要获取用户授权，如果用户拒绝授权则返回开始失败结果。
     * @example
     * ```js
     * import { ScreenShareError } from '@polyv/live-watch-sdk';
     *
     * async function startScreenShare() {
     *   const result = await watchCore.connectMic.startScreenShare();
     *   if (result.success) {
     *     const info = watchCore.connectMic.getScreenShareInfo();
     *     console.log('已进入屏幕共享', info.isScreenSharing); // true
     *     return;
     *   }
     *
     *   if (result.failReason === ScreenShareError.BrowserNotSupport) {
     *     toast.error('屏幕共享失败，您拒绝了系统权限');
     *   }
     * }
     * ```
     */
    startScreenShare(): Promise<ScreenShareResult>;
    /**
     * 停止屏幕共享
     *
     * 通过 `stopScreenShare` 停止屏幕共享，通过 {@link ConnectMicEvents.ScreenShareStop} 事件监听屏幕共享结束。
     * @example
     * ```js
     * // 结束屏幕共享
     * watchCore.connectMic.stopScreenShare();
     * ```
     */
    stopScreenShare(): Promise<ScreenShareResult>;
    /**
     * 显示用户摄像头（画中画）
     *
     * 屏幕共享开启后，可通过 `enterPip` 显示用户的摄像头，进入画中画模式。
     * @example
     * ```js
     * // 显示画中画
     * await watchCore.connectMic.enterPip();
     * const info = watchCore.connectMic.getScreenShareInfo();
     * console.log('是否正在画中画模式', info.isPiping); // true
     * ```
     */
    enterPip(): Promise<void>;
    /**
     * 隐藏用户摄像头（画中画）
     *
     * 屏幕共享开启后，可通过 `exitPip` 隐藏用户的摄像头，推出画中画模式。
     * @example
     * ```js
     * // 隐藏画中画
     * await watchCore.connectMic.exitPip();
     * const info = watchCore.connectMic.getScreenShareInfo();
     * console.log('是否正在画中画模式', info.isPiping); // false
     * ```
     */
    exitPip(): Promise<void>;
    /**
     * 恢复所有流播放
     *
     * 当 RTC 流播放失败时，可通过 `resumeAllStreams` 恢复所有流的播放。
     * @example
     * ```js
     * // 恢复所有流播放
     * await watchCore.connectMic.resumeAllStreams();
     * ```
     */
    resumeAllStreams(): Promise<void>;
    /** 音量定时器 */
    private __volumeTimer?;
    /**
     * 设置音量定时器
     */
    private __setVolumeTimer;
    /**
     * 销毁音量定时器
     */
    private __clearVolumeTimer;
    /**
     * 设置静音状态
     * @param streamId 流 id
     * @param isAudioMuted 是否静音
     */
    private __setMicItemAudioMuted;
    /**
     * 设置摄像头状态
     * @param streamId 流 id
     * @param isVideoMuted 是否关闭摄像头
     */
    private __setMicItemVideoMuted;
    /**
     * 设置第一画面
     * @param streamId 流 id
     */
    private __setMaster;
    /**
     * 移除本地流对象
     */
    private __removeLocalMicItem;
    /**
     * 根据流 id 寻找连麦节点索引
     * @internal
     * @ignore
     * @param streamId 流 id
     */
    findMicItemIndex(streamId: string | number): number;
    /**
     * 根据流 id 寻找连麦节点
     * @internal
     * @ignore
     * @param streamId 流 id
     */
    findMicItem(streamId: string | number): ConnectMicItem | undefined;
    /**
     * 获取本地流连麦用户节点
     * @internal
     * @ignore
     */
    getLocalMicItem(): ConnectMicItem | undefined;
    /**
     * 判断连麦列表是否存在观众模式
     * @private
     */
    private __hasAudienceInList;
    /**
     * 更新当前用户的连麦序号
     * @internal
     * @ignore
     * @param index 序号
     */
    updateCurrentMicIndex(index: number): void;
    /**
     * 设置是否为主讲
     * @internal
     * @ignore
     */
    setIsSpeaker(isSpeaker?: boolean, emitEvent?: boolean): void;
    /**
     * 销毁连麦
     * @internal
     * @ignore
     * @version v0.9.0
     */
    destroyConnectMic(): void;
    /**
     * 销毁连麦
     * @internal
     * @ignore
     */
    destroy(): void;
}

/**
 * 保利威默认资源链接
 */
export declare interface PlvDefaultResource {
    /** 默认观众头像 */
    defaultViewerAvatar: string;
    /** 默认引导页封面图 */
    defaultSplashImg: string;
    /** 默认引导页大图封面图 */
    defaultSplashFullImg: string;
    /** 默认的回放首帧占位图 */
    defaultPlaybackPlaceholder: string;
    /** 默认的浏览器 ico */
    defaultBrowserIcon: string;
    /** 默认的频道 logo */
    defaultChannelLogo: string;
    /** 默认图标（微活动） */
    defaultWidgetGame: string;
    /** 默认点赞图标 */
    defaultLikeIcon: string;
}

export declare interface PlvDevicemotionSwitchEventMessage {
    type: MicroActivityIframeEventType.PLV_DEVICEMOTION_SWITCH;
    data: {
        accelerationIncludingGravity: {
            x: number;
            y: number;
            z: number;
        };
    };
}

/**
 * 文档模块
 * @class
 */
export declare class PlvDocModule extends ModuleBase {
    /** 事件触发器 */
    eventEmitter: EventEmitter<DocEventsRelations, DocEvents>;
    __docSocketService: DocSocketService;
    private __docCtrl?;
    private __currentOptions?;
    private __currentPlaybackOptions?;
    /**
     * 生成默认的文档模块信息
     * @version v1.2.0
     */
    static generateDefaultDocInfo(): DocModuleInfo;
    /** 文档模块信息 */
    private __docInfo;
    /**
     * 更新文档模块信息
     * @internal
     * @ignore
     * @param docInfo 文档信息
     */
    updateDocInfo(docInfo: Partial<DocModuleInfo>): void;
    /**
     * 获取文档信息
     * @api
     * @version v0.7.0
     * @returns 文档信息
     * @example
     * ```js
     * const docInfo = watchCore.doc.getDocInfo();
     * console.log('是否具有画笔权限', docInfo.hasPaintAuth);
     * console.log('是否处于画笔模式', docInfo.paintMode);
     * ```
     */
    getDocInfo(): DocModuleInfo;
    bindChatEvents(): void;
    bindSocketEvents(): void;
    /**
     * 是否使用白板 SDK 来渲染文档
     */
    private __useWhiteboardSdkEnabled;
    updateAppConfig(appConfig: Partial<AppConfig>): void;
    private __handleLiveStatusChange;
    private __listenModuleEvents;
    private __unlistenModuleEvents;
    /**
     * 设置文档
     * @api
     */
    setupDoc(options: SetupDocOptions): Promise<void>;
    /**
     * 获取文档设置配置
     * @internal
     * @ignore
     */
    getSetupDocOptions(): SetupDocOptions | undefined;
    /**
     * 重新设置文档
     * @api
     */
    resetUpDoc(options?: SetupDocOptions | undefined): void;
    /**
     * 设置水印
     * @internal
     * @ignore
     */
    setWatermark(): void;
    /**
     * 重置尺寸
     * @api
     */
    resize(): void;
    /**
     * @ignore
     * @internal
     */
    syncViewerPptTurningEnabled(): void;
    /**
     * 设置回放
     * @internal
     * @ignore
     * @param options 选项
     * @param force 是否强制切换，默认 false
     */
    setupPlayback(options: SetupDocPlaybackOptions, force?: boolean): Promise<void>;
    /**
     * 根据播放器选项设置回放
     * @internal
     * @ignore
     */
    setupPlaybackByPlayerOptions(force?: boolean): void;
    /**
     * 切换到下一步
     * @api
     */
    gotoNext(): void;
    /**
     * 切换到上一步
     * @api
     */
    gotoPrev(): void;
    /**
     * 进入画笔模式
     * @version v0.7.0
     * @api
     */
    enterPaintMode(): void;
    /**
     * 退出画笔模式
     * @version v0.7.0
     * @api
     */
    exitPaintMode(): void;
    /**
     * 设置键盘控制
     * @version v2.3.0
     */
    setKeyboardEnabled(enabled: boolean): void;
    /**
     * 切换语言
     * @version v0.7.0
     * @internal
     * @ignore
     */
    switchLang(lang: string): void;
    /**
     * 获取 drawMark 数据
     * @internal
     * @ignore
     */
    getDrawMark(): Record<string, string[]> | undefined;
    /**
     * 销毁文档
     * @api
     */
    destroyDoc(): void;
    destroy(): void;
}

/**
 * 域名模块
 * @class
 */
export declare class PlvDomainModule extends ModuleBase {
    /** 默认的域名 */
    static generateDefaultDomainInfo: () => DomainInfo;
    /**
     * watchPageDomain 是否跟随后台配置
     * @desc 从 v2.15.0 开始默认改为 true
     */
    private __followWatchApiDomain;
    /**
     * 设置 watchPageDomain 跟随后台 watchApiDomain 配置
     * @version v1.1.0
     * @desc 由于业务原因, watchPageDomain 目前并没有响应后台配置，如果需要响应后台配置，则可以调用该方法进行设置，但 sdk 的初始化传参依旧为最高优先级
     * @internal
     * @ignore
     */
    setFollowWatchApiDomain(bool: boolean): void;
    /** 入参的域名信息 */
    private __optionDomainInfo;
    /** detail 中的域名信息 */
    private __detailDomainInfo;
    /** 获取全局注入的域名配置 */
    private __getWindowInjectDomainInfo;
    /**
     * 获取域名信息
     */
    getDomainInfo(): DomainInfo;
    updateAppConfig(appConfig: Partial<AppConfig>): void;
    setup(): void;
    /**
     * 处理随机域名 hostname
     * @desc 仅提供给泛域名的客户使用，会根据后台配置去生成随机域名 hostname，默认返回当前传入的 url
     * @version v1.6.0
     * */
    processRandomHostname(url: string): string;
}

/**
 * 域名模块
 * @class
 */
declare class PlvDomainModule_2 extends ModuleBase_2 {
    /** 默认的域名 */
    static generateDefaultDomainInfo: () => DomainInfo_3;
    /** 入参的域名信息 */
    private __optionDomainInfo;
    /** detail 中的域名信息 */
    private __detailDomainInfo;
    /** 获取全局注入的域名配置 */
    private __getWindowInjectDomainInfo;
    updateAppConfig(appConfig: Partial<OmitAppConfig_2>): void;
    /**
     * 获取域名信息
     */
    getDomainInfo(): DomainInfo_3;
}

/**
 * 打赏模块
 * @class
 */
export declare class PlvDonateModule extends ModuleBase {
    /**
     * 生成默认的频道打赏配置
     * @version v1.2.0
     */
    static generateDefaultDonateConfig(): DonateConfig;
    /**
     * 获取频道打赏配置
     *
     * 从 v1.2.0 开始可以通过 `PlvDonateModule.generateDefaultDonateConfig()` 来获取默认配置
     *
     * @returns 频道打赏配置
     * @example
     * ```js
     * const donateConfig = watchCore.donate.getDonateConfig();
     * console.log('现金打赏开关', donateConfig.donateCashEnabled);
     * console.log('现金礼物打赏开关', donateConfig.donateGoodEnabled);
     * console.log('积分礼物打赏开关', donateConfig.donatePointEnabled);
     * ```
     */
    getDonateConfig(): DonateConfig;
    /**
     * 判断是否显示现金打赏
     * @returns 是否显示现金打赏
     * @example
     * ```js
     * const check = watchCore.donate.isShowDonateCash();
     * if (check) {
     *   // TODO：显示现金打赏
     * } else {
     *   // TODO：隐藏现金打赏
     * }
     * ```
     */
    isShowDonateCash(): boolean;
    /**
     * 判断是否显示现金道具打赏
     * @returns 是否显示现金道具打赏
     * @example
     * ```js
     * const check = watchCore.donate.isShowDonateCashGood();
     * if (check) {
     *   // TODO：显示现金道具打赏
     * } else {
     *   // TODO：隐藏现金道具打赏
     * }
     * ```
     */
    isShowDonateCashGood(): boolean;
    /**
     * 是否显示积分道具打赏
     * @returns 是否显示积分道具打赏
     * @example
     * ```js
     * const check = watchCore.donate.isShowDonatePointGood();
     * if (check) {
     *   // TODO：显示积分道具打赏
     * } else {
     *   // TODO：隐藏积分道具打赏
     * }
     * ```
     */
    isShowDonatePointGood(): boolean;
    /** 是否存在免费的道具 */
    protected _isExistFreeGood(): boolean;
    /**
     * 判断是否为免费礼物
     *
     * 通过打赏道具名称以及管理后台配置的打赏设置判断礼物是否免费，如果不在配置中的礼物将返回 false。
     * @param rewardContent 打赏内容（道具名称）
     * @example
     * ```js
     * const check = watchCore.donate.isFreeReward('鲜花');
     * if (check) {
     *   console.log('礼物是免费的');
     * } else {
     *   console.log('礼物是收费的');
     * }
     * ```
     */
    isFreeReward(rewardContent: string): boolean;
    /**
     * 格式化打赏道具列表
     * @param goodList 打赏道具列表
     */
    private __formateGoodList;
    /** 获取积分打赏道具 */
    protected _getPointGoods(): DonateGoodData[];
    /** 获取现金打赏道具 */
    protected _getCashGoods(): DonateGoodData[];
    /**
     * 获取打赏道具信息
     *
     * 获取管理后台中设置的打赏道具信息，如积分打赏道具、现金打赏道具
     * @example
     * ```js
     * const info = watchCore.donate.getDonateGoods();
     * console.log('当前支持显示的打赏道具', info.goods);
     * console.log('后台设置的现金道具', info.cashGoods);
     * console.log('后台设置的积分道具', info.pointGoods);
     * ```
     */
    getDonateGoods(): {
        /** 当前支持打赏的道具 */
        goods: DonateGoodData[];
        /** 现金道具 */
        cashGoods: DonateGoodData[];
        /** 积分道具 */
        pointGoods: DonateGoodData[];
    };
    /**
     * 支付打赏
     *
     * 当观众进行打赏时，可调用 `payDonate` 进行打赏，调用后可通过支付记录 id `logId` 查询支付状态。
     * @param params 打赏内容
     * @example
     * ```js
     * import { DonateType } from '@polyv/live-watch-sdk';
     *
     * // 现金打赏
     * const payData = await watchCore.donate.payDonate({
     *   donateType: DonateType.Cash,
     *   amount: '1.2', // 1.2 元
     * });
     *
     * // 道具打赏
     * const payData = await watchCore.donate.payDonate({
     *   donateType: DonateType.Good,
     *   goodId: 'xxx',
     *   goodCount: 2,
     * });
     *
     * // 调用后的处理
     * if (payData.isFree) {
     *   // 免费道具，无需支付
     *   return;
     * }
     *
     * if (isPC) {
     *   // PC 端使用扫码支付
     *   toast.success('显示支付二维码', payData.qrCodeUrl);
     *   return;
     * }
     *
     * if (isMobile && isWeixin) {
     *   // 移动端微信环境下调用微信 JSSDK 支付接口
     *   const wxPaySignData = payData.wxPaySignData;
     *   wx.chooseWXPay({
     *     timestamp: wxPaySignData.timestamp,
     *     nonceStr: wxPaySignData.nonceStr,
     *     package: wxPaySignData.package,
     *     signType: wxPaySignData.signType,
     *     paySign: wxPaySignData.paySign,
     *     success: () => {
     *       toast.success('支付成功');
     *     },
     *     fail: () => {
     *       toast.success('支付失败');
     *     },
     *   });
     *   return;
     * }
     *
     * toast.error('请使用微信客户端打开');
     * ```
     */
    payDonate(params: PayDonateParams): Promise<PayDonateData>;
    /**
     * 检查打赏支付状态
     */
    checkDonatePayStatus(params: CheckDonatePayStatusParams): Promise<DonatePayStatusData>;
    /**
     * 获取当前用户打赏的剩余积分
     * @api
     */
    getDonateSurplusPoint(): Promise<number>;
    /**
     * 支付积分打赏
     * @returns 返回剩余积分
     */
    payDonatePoint(params: PayDonatePointParams): Promise<number>;
    static svgaMap: UniversalParams<string>;
    private __getDefaultSvgaDir;
    /**
     * 获取打赏 svga 链接
     * @version v1.0.0
     * @param gimg 打赏图片地址
     */
    getDonateSvgaUrl(gimg: string): string | undefined;
}

/**
 * 表情模块
 * @class
 * @version v2.0.0
 */
export declare class PlvEmotionModule extends ModuleBase {
    private __emotionParser?;
    /**
     * 加载表情解析器
     *
     * 开发者需要在调用表情模块的其他方法前，需要优先调用该方法
     *
     * @example
     * ```js
     * // 安装观看页 SDK
     * await watchCore.setup();
     * // 加载表情功能
     * await watchCore.interactReceive.setupEmotionParser();
     * // 加载后即可调用表情模块的其他方法
     * ```
     */
    setupEmotionParser(): Promise<void>;
    /**
     * 获取表情解析器
     * @internal
     * @ignore
     */
    getEmotionParser(): EmotionParser | undefined;
    /**
     * 获取黄脸表情节点
     *
     * 开发者可通过 `getEmotionFaceDomList` 方法获取节点并插入到页面容器中。
     *
     * 监听容器的点击事件并调用 {@link getEmotionFaceClickTarget} 方法可获取观众点击时的黄脸表情。
     * @returns 黄脸表情 dom 节点
     * @example
     * ```js
     * const containerElem = document.querySelector('容器选择器');
     * // 插入表情节点
     * const elems = watchCore.chat.getEmotionFaceDomList();
     * containerElem.appendChild(elems);
     * // 监听容器节点的点击事件
     * containerElem.addEventListener('click', function(event) {
     *   const title = watchCore.emotion.getEmotionFaceClickTarget(event);
     *   console.log('点击的表情', title);
     * });
     * ```
     */
    getEmotionFaceDomList(lang?: LanguageType): HTMLElement;
    /**
     * 获取点击事件中的黄脸表情
     *
     * 用于获取观众点击黄脸表情容器时的表情对象，获取后插入到观众正在输入的聊天消息文本中。
     * @param event 点击事件
     * @returns 黄脸表情字符
     * @example
     * ```js
     * // 观众正在输入的聊天消息
     * const inputMsg = '今天天气真好';
     *
     * // 监听容器节点的点击事件
     * containerElem.addEventListener('click', function(event) {
     *   const title = watchCore.emotion.getEmotionFaceClickTarget(event);
     *   if (title) {
     *     console.log('点击的表情', title); // 如：[呲牙]、[害羞]
     *     inputMsg = inputMsg + title;
     *   }
     * });
     * ```
     */
    getEmotionFaceClickTarget(event: Event): string | undefined;
    /**
     * 把表情名称转成中文
     * @param content 发言内容
     * @returns 转换后的内容
     * @example
     * ```js
     * // 聊天发言内容
     * let content = '';
     * // 返回转换后的内容
     * let translatedContent =await watchCore.emotion.translateEmotions(content);
     * ```
     */
    translateEmotions(content: string, lang?: WatchSdkLangEnum): string;
    /**
     * 加载 promise，避免多次加载
     */
    private __getEmotionImagePromise;
    /**
     * 获取表情图片列表
     *
     * 通过 `getEmotionImages` 获取标题图片列表，获取该列表后，使用 `id`、`url` 调用 {@link ChatModule.sendEmotionImageMsg} 发送表情图片消息。
     * @example
     * ```js
     * const emotionImages = await watchCore.emotion.getEmotionImages();
     * // 表情图片列表数据示例：
     * [{ id: '0', title: '收到', url: 'https://s2.videocc.net/default-img/img-emotion/v1/shoudao.png' }]
     *
     * // 发送表情图片
     * const item = emotionImages[2];
     * watchCore.chat.sendEmotionImageMsg({
     *   emotionId: item.id,
     *   emotionUrl: item.url,
     * });
     * ```
     */
    getEmotionImages(): Promise<EmotionImageData[]>;
}

/**
 * 报名观看模块
 * @class
 */
export declare class PlvEnrollModule extends ModuleBase {
    /** 报名观看事件触发器 */
    eventEmitter: EventEmitter<EnrollEventsRelations, EnrollEvents>;
    /**
     * 生成默认的报名观看信息
     * @version v1.2.0
     */
    static generateDefaultEnrollInfo(): EnrollModuleInfo;
    /** 报名观看信息 */
    private __enrollInfo;
    /**
     * 更新报名观看信息
     */
    updateEnrollInfo(info: Partial<EnrollModuleInfo>): void;
    /**
     * 获取报名观看信息
     */
    getEnrollInfo(): EnrollModuleInfo;
    constructor(_watchCore: PolyvWatchCore);
    /**
     * 报名观看模块初始化设置
     * */
    setup(): void;
    /**
     * 获取报名观看开关
     * @version v0.8.0
     */
    getEnrollEnabled(): boolean;
    /**
     * 获取报名观看表单字段列表
     * @param enrollSetting 报名观看设置
     */
    private __getEnrollFields;
    /**
     * 获取报名观看的验证方式
     * @param enrollSetting 报名观看设置
     */
    private __getEnrollAuthType;
    /**
     * 获取短信验证开关
     * @param enrollSetting 报名观看设置
     */
    private __getSmsVerifyEnabled;
    /**
     * 获取手机区号开关
     * @param enrollSetting 报名观看设置
     * @returns 手机区号开关
     */
    private __getAreaCodeEnabled;
    /**
     * 获取短信验证开关
     * @version v0.8.0
     */
    getSmsVerifyEnabled(): boolean;
    /**
     * 获取报名观看表单字段列表
     * @api
     */
    getEnrollFields(): EnrollFieldItem[];
    /**
     * 获取报名观看的验证方式
     * @api
     */
    getEnrollAuthType(): EnrollAuthType;
    /**
     * 提交报名观看表单
     * @api
     */
    submitEnrollForm(params: SubmitEnrollFormParams): Promise<CommonResult<SubmitEnrollError, EnrollResultData>>;
    /**
     * 获取报名状态
     * @api
     */
    getEnrollStatus(params: GetEnrollStatusParams): Promise<EnrollResultData>;
    /**
     * 使用验证手机号或邮箱登录报名观看
     * @api
     */
    loginEnroll(params: LoginEnrollParams): Promise<CommonResult<SubmitEnrollError, EnrollResultData>>;
    /**
     * @internal
     * @ignore
     */
    destroy(): void;
}

/**
 * 金融-风险确认（风险确认函）
 * @version v1.2.0 开始才能正常使用
 * @class
 */
export declare class PlvFinanceRiskConfirmModule extends ModuleBase {
    /**
     * 获取默认的风险确认函配置
     */
    static generateDefaultRiskConfirmSetting(): FinanceRiskConfirmSetting;
    /**
     * 通过分析 dom 节点来获取风险确认协议
     *
     * @desc 通过 {@link getViewerRiskConfirmInfo} 方法获取 content 字段后，可以用来渲染 Dom 节点后。监听 Dom 节点的点击事件来查看链接协议是，则可以通过该方法传入 dom 节点来获取协议数据
     */
    getRiskConfirmAgreementByContentDom(dom: HTMLElement): CommonResult<'inValidDom', FinanceRiskConfirmAgreement>;
    /**
     * 获取风险确认函设置
     */
    getRiskConfirmSetting(): FinanceRiskConfirmSetting;
    /**
     * 获取观众风险确认函信息
     */
    getViewerRiskConfirmInfo(): Promise<CommonResult<'unknown', FinanceRiskConfirmInfo>>;
    /**
     * 同意风险确认
     */
    agreeRiskConfirm(): Promise<CommonResult<'unknown', object>>;
}

/**
 * 金融-风险测评
 * @version v1.2.0 开始才能正常使用
 * @class
 */
export declare class PlvFinanceRiskEvaluationModule extends ModuleBase {
    /**
     * 获取默认风险测评数据
     * @desc 设置一个默认值来走通流程，默认情况为“后置-自愿填写”
     */
    static generateDefaultRiskEvaluation(): FinanceRiskEvaluation;
    /** 事件触发器 */
    eventEmitter: EventEmitter<FinanceRiskEvaluationEventsRelations, FinanceRiskEvaluationEvents>;
    /** 金融-风险测评 Socket 服务 */
    private __financeRiskEvaluationSocketService;
    /**
     * socket 事件绑定钩子
     * @internal
     * @ignore
     * */
    bindSocketEvents(): void;
    /**
     * 获取风险测评设置
     */
    getRiskEvaluationSetting(): FinanceRiskEvaluation;
    /**
     * 判断是否通过风险测评
     * @tip 注意，当 evaluationLimitType === EvaluationLimitType.Pendant 时，passEvaluation 默认为 1
     */
    judgeIsPassRiskEvaluation(riskEvaluation: FinanceRiskEvaluation): boolean;
    /**
     * 前置条件下，判断是否需要展示风险测评窗口
     */
    judgeNeedShowRiskEvaluationInPre(riskEvaluation: FinanceRiskEvaluation): boolean;
    /**
     * 后置条件测评时机下，判断是否需要展示挂件
     */
    judgeNeedShowRiskEvaluationInAfter(riskEvaluation: FinanceRiskEvaluation): boolean;
    /**
     * 判断是否为前置条件测评时机
     */
    judgeIsPreLimitType(riskEvaluation: FinanceRiskEvaluation | FinanceRiskEvaluationSocketData): boolean;
    /**
     * 判断是否为后置条件测评时机
     */
    judgeIsAfterLimitType(riskEvaluation: FinanceRiskEvaluation | FinanceRiskEvaluationSocketData): boolean;
    /**
     * 后置条件测评时机下，获取挂件倒计时，返回"秒"级别
     */
    getPendantCountDownTime(riskEvaluation: FinanceRiskEvaluation): number;
}

/**
 * 认证登录核心模块
 * @class
 * @version v2.0.0
 */
declare class PlvIdentityCoreModule extends ModuleBase {
    /** 聊天室 SDK 实例 */
    private __identifyCore?;
    constructor(_watchCore: PolyvWatchCore);
    /**
     * 安装 identifyCore 模块
     */
    protected _setupIdentifyCoreModule(): Promise<void>;
    /**
     * 获取聊天室 SDK 实例
     * @internal
     * @ignore
     * @param check 检查是否存在 identifyCore
     * @throws 当 identifyCore 未创建时抛错
     */
    getIdentifyCore(check?: true): IdentifyCore;
    /**
     * 获取聊天室 SDK 实例
     * @internal
     * @ignore
     * @param check 无需检查 identifyCore 是否存在
     */
    getIdentifyCore(check?: false): IdentifyCore | undefined;
    /**
     * 销毁 identifyCore 模块
     */
    protected _destroyIdentifyCoreModule(): void;
}

/**
 * 身份模块
 * @class
 * @version v1.2.0
 */
export declare class PlvIdentityModule extends PlvIdentityCoreModule {
    /**
     * 获取用户唯一信息
     */
    getIdentityUnionInfo(): IdentityUnionInfo | undefined;
    /**
     * 获取用户来源信息
     */
    getIdentitySourceInfo(): SourceInfo | undefined;
    private __updateIdentityUnionInfo;
    /**
     * 获取后端接口返回的用户信息
     */
    private __getApiViewerUnionInfo;
    setup(): Promise<void>;
    /**
     * 获取默认的“用户身份配置”
     */
    static generateDefaultIdentitySetting(): IdentitySetting;
    /**
     * 获取用户身份配置
     */
    getIdentitySetting(): IdentitySetting;
    /**
     * 获取游客外链登录配置
     * @version v2.10.0
     */
    getIdentifyGuestLinkLoginConfig(): LinkData | null;
    /**
     * 检查是否需要进行用户身份信息登录
     * @version v2.0.0
     */
    checkIdentityLogin(): boolean;
    /**
     * 是否允许验证独立授权
     * @version v2.8.0
     */
    allowToVerifyDirectAuth(signParams: IdentityDirectAuthParams): boolean;
    /**
     * 登录用户系统
     */
    loginIdentityInfo(params?: LoginIdentityInfoParams): Promise<CommonResult<IdentityInfoFailReason>>;
    /**
     * 绑定用户身份信息
     */
    bindIdentityInfo(params?: BindIdentityInfoParams): Promise<CommonResult<IdentityInfoFailReason>>;
    /**
     * @internal
     * @ignore
     * @version v1.11.0
     */
    getProfilePageId(): string;
    /**
     * 检查是否开启采集信息
     * @version v2.3.0
     */
    checkCollectEnabled(): Promise<boolean>;
    /**
     * 检查是否需要走企微的静默授权
     * @version v2.6.0
     */
    checkWorkWxSnsApiBaseEnabled(): boolean;
    private __hasQWLoginType;
    /**
     * 用户体系-校验并确保执行企微静默授权
     * @version v2.6.0
     */
    ensureWorkWxSnsAuth(options: EnsureWxAuthOptions): Promise<{
        redirected: boolean;
    }>;
    destroy(): void;
}

/**
 * 互动接收端模块
 * @class
 */
export declare class PlvInteractReceiveModule extends PlvInteractReceiveRebuild {
    /**
     * 事件触发器
     */
    eventEmitter: EventEmitter<InteractReceiveEventsRelations, InteractReceiveEvents>;
    /**
     * 互动接收端模块 Socket 服务
     */
    private __iarSocketService;
    /**
     * 互动接收端模块回放服务
     */
    private __iarReplayLogicService;
    /**
     * 互动-卡片推送重放服务
     */
    private __iarReplayPushCardService;
    /**
     * 互动-签到重放服务
     */
    private __iarReplayCheckInService;
    /**
     * 互动-答题卡重放服务
     */
    private __iarReplayAnswerCardService;
    /**
     * 互动-问卷重放服务
     */
    private __iarReplayQuestionnaireService;
    /**
     * 模块事件绑定服务
     */
    private __bindModuleEventServices;
    /**
     * 检查互动 SDK 是否加载完成
     * @internal
     * @ignore
     */
    checkIarSdkLoaded(): boolean;
    /**
     * @internal
     * @ignore
     */
    setup(): void;
    /**
     * @internal
     * @ignore
     * */
    bindSocketEvents(): void;
    /**
     * 获取互动接收端功能 SDK 对象
     * @internal
     * @ignore
     * @param check 检查 `window.PolyvIRSDK` 的存在
     * @throws 当 `window.PolyvIRSDK` 不存在时抛错
     * */
    getIarCore(check?: true): PolyvIRSDKType;
    /**
     * 获取互动接收端功能 SDK 对象
     * @internal
     * @ignore
     * @param check 无需检查 `window.PolyvIRSDK` 的存在
     * */
    getIarCore(check?: false): PolyvIRSDKType | undefined;
    /**
     * 从 window 中获取互动功能 SDK 对象
     * @internal
     * @ignore
     */
    get PolyvIRSDK(): PolyvIRSDKType;
    /**
     * 安装互动接收端 SDK
     *
     * 观看页 SDK 默认不会加载互动功能接收端 SDK，如需使用互动功能，请在 `watchCore.setup()` 之后调用该方法加载互动功能接收端 SDK。
     * @example
     * ```js
     * // 安装观看页 SDK
     * await watchCore.setup();
     * // 加载互动功能
     * await watchCore.interactReceive.setupIarCore();
     * // 加载后即可获取互动功能单一实例
     * ```
     */
    setupIarCore(): Promise<void>;
    /**
     * 获取互动功能接收端需要的一些基础配置
     * */
    private __getIarBasicConfig;
    /**
     * @internal
     * @ignore
     * @version v1.8.0
     */
    updateIarViewerToken(token: string): void;
    /**
     * 更新互动功能接收端的配置
     */
    private __updateIarConfig;
    private __setupIarModule;
    /**
     * 生成默认的互动设置信息
     * @version v1.2.0
     */
    static generateDefaultInteractSetting(): InteractSetting;
    /** 互动设置信息 */
    private __interactSetting;
    /**
     * 修改互动设置信息
     * @internal
     * @ignore
     * @param setting 设置对象
     */
    setInteractSetting(setting?: Partial<InteractSetting>): void;
    /**
     * 获取互动设置信息
     *
     * 用于获取管理后台设置的互动功能信息。
     * @example
     * ```js
     * const settingInfo = watchCore.interactReceive.getInteractSetting();
     * console.log('商品库开关', settingInfo.productEnabled);
     * ```
     */
    getInteractSetting(): InteractSetting;
    /**
     * 公告 SDK 单一实例
     */
    private __announcement;
    /**
     * 获取公告 SDK 单一实例
     *
     * 公告功能开发文档：
     * [公告 SDK](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/sdk/notice)、
     * [公告组件](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/ui/default/notice)
     * @returns 公告 SDK 单一实例
     */
    getAnnouncement(): IarAnnouncement;
    /**
     * 签到 SDK 单一实例
     */
    private __checkIn;
    /**
     * 获取签到 SDK 单一实例
     *
     * 签到功能开发文档：
     * [签到 SDK](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/sdk/check_in)、
     * [签到组件](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/ui/default/check_in)
     * @returns 签到 SDK 单一实例
     */
    getCheckIn(): IarCheckIn;
    /**
     * 答题卡 SDK 单一实例
     */
    private __answerCard;
    /**
     * 获取答题卡 SDK 单一实例
     *
     * 答题卡功能开发文档：
     * [答题卡 SDK](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/sdk/answer_card)、
     * [答题卡组件](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/ui/default/answer_card)
     * @returns 答题卡 SDK 单一实例
     */
    getAnswerCard(): IarAnswerCard;
    /**
     * 问卷 SDK 单一实例
     */
    private __questionnaire;
    /**
     * 获取问卷 SDK 单一实例
     *
     * 问卷功能开发文档：
     * [问卷 SDK](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/sdk/questionnaire)、
     * [问卷组件](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/ui/default/questionnaire)
     * @returns 问卷 SDK 单一实例
     */
    getQuestionnaire(): IarQuestionnaire;
    /**
     * 问答 SDK 单一实例
     */
    private __questionAnswer;
    /**
     * 获取问答 SDK 单一实例
     *
     * 问答功能开发文档：
     * [问答 SDK](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/sdk/question_answer)、
     * [问答组件](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/ui/default/question_answer)
     * @returns 问答 SDK 单一实例
     */
    getQuestionAnswer(): IarQuestionAnswer;
    /**
     * 卡片推送 SDK 单一实例
     */
    private __pushCard;
    /**
     * 获取卡片推送 SDK 单一实例
     *
     * 卡片推送功能开发文档：
     * [卡片推送 SDK](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/sdk/push_card)、
     * [卡片推送组件](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/ui/default/push_card)
     * @returns 卡片推送 SDK 单一实例
     */
    getPushCard(): IarPushCard;
    /**
     * 抽奖 SDK 单一实例
     */
    private __lottery;
    /**
     * 获取抽奖 SDK 单一实例
     *
     * 抽奖功能开发文档：
     * [抽奖 SDK](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/sdk/lottery)、
     * [抽奖组件](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/ui/default/lottery)
     * @returns 抽奖 SDK 单一实例
     */
    getLottery(): IarLottery;
    /**
     * 条件抽奖 SDK 单一实例
     */
    private __welfareLottery;
    /**
     * 获取条件抽奖 SDK 单一实例
     *
     * 条件抽奖功能开发文档：
     * [条件抽奖 SDK](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/sdk/welfare_lottery)、
     * [条件抽奖组件](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/ui/default/welfare_lottery)
     * @returns 条件抽奖 SDK 单一实例
     */
    getWelfareLottery(): IarWelfareLottery;
    /**
     * 报名抽奖 SDK 单一实例
     */
    private __enrollLottery;
    /**
     * 获取报名抽奖 SDK 单一实例
     *
     * 报名抽奖功能开发文档：
     * [报名抽奖 SDK](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/sdk/enroll_lottery)、
     * [报名抽奖组件](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/ui/default/enroll_lottery)
     * @returns 报名抽奖 SDK 单一实例
     */
    getEnrollLottery(): IarEnrollLottery;
    /**
     * 红包 SDK 单一实例
     */
    private __redpack;
    /**
     * 获取红包 SDK 单一实例
     *
     * 红包功能开发文档：
     * [红包组件](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/ui/default/redpacket)
     * @returns 红包 SDK 单一实例
     */
    getRedpack(): IarRedpack;
    /**
     * 红包雨 SDK 单一实例
     */
    private __redpackRain;
    /**
     * 获取红包雨 SDK 单一实例
     *
     * 目前红包雨和红包共用一份 [文档](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/ui/default/redpacket)
     * @returns 红包雨 SDK 单一实例
     */
    getRedpackRain(): IarRedpackRain;
    /**
     * 投票 SDK 单一实例
     */
    private __vote;
    /**
     * 获取投票 SDK 单一实例
     *
     * 暂无相关文档，后续补充...
     * @returns 投票 SDK 单一实例
     */
    getVote(): IarVote;
    /**
     * 反馈 SDK 单一实例
     */
    private __feedback;
    /**
     * 获取反馈 SDK 单一实例
     *
     * 暂无相关文档，后续补充...
     * @returns 反馈 SDK 单一实例
     */
    getFeedBack(): IarFeedBack;
    /**
     * 商品库 SDK 单一实例
     */
    private __product;
    /**
     * 获取商品库 SDK 单一实例
     *
     * 商品库功能开发文档：
     * [商品库 SDK](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/sdk/product)、
     * [商品库组件](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/ui/default/product)
     * @returns 商品库 SDK 单一实例
     */
    getProduct(): IarProduct;
    /**
     * 商品库回放
     * @version v0.9.0
     * */
    processProductReplay(params: PlayerEventsRelations[PlayerEvents.TimeUpdate]): void;
    /**
     * 图文直播 SDK 单一实例
     */
    private __tuwen;
    /**
     * 获取图文直播 SDK 单一实例
     *
     * 图文直播功能开发文档：
     * [图文直播 SDK](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/sdk/tuwen)、
     * [图文直播组件](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/ui/default/tuwen)
     * @returns 图文直播 SDK 单一实例
     */
    getTuwen(): IarTuwen;
    /**
     * 云席 SDK 单一实例
     */
    private __seatTable;
    /**
     * 获取云席 SDK 单一实例
     * @returns 云席 SDK 单一实例
     */
    getSeatTable(): IarSeatTable;
    /**
     * 设置云席信息
     * @version v0.10.0
     */
    setupSeatTable(): Promise<void>;
    /**
     * 话题PK SDK 单一实例
     */
    private __topicPK;
    /**
     * 获取话题PK SDK 单一实例
     *
     * 话题PK功能开发文档：
     * [话题PK SDK](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/sdk/topic)、
     * [话题PK组件](https://help.polyv.net/index.html#/live/js/new_sdk/interactions_receive_sdk/ui/default/topic)
     * @returns 话题PK SDK 单一实例
     */
    getTopicPK(): IarTopicPK;
    /**
     * 抢答 SDK 单一实例
     */
    private __rushAnswer;
    /**
     * 获取抢答 SDK 单一实例
     * @returns 抢答 SDK 单一实例
     */
    getRushAnswer(): IarRushAnswer;
    /**
     * 获取商品库按钮点击提示模板配置
     * @returns 商品库按钮点击提示模板
     * @version v1.3.0
     */
    getProductLinkJumpTipDetail(): ProductLinkJumpTipDetail | undefined;
    /**
     * 地址管理 SDK 单一实例
     */
    private __addressManagement;
    /**
     * 地址管理 SDK 单一实例
     * @version v1.5.0
     * @returns 地址管理 SDK 单一实例
     */
    getAddressManagement(): IarAddressManagement;
    /**
     * 订单 SDK 单一实例
     */
    private __order;
    /**
     * 订单 SDK 单一实例
     * @version v1.5.0
     * @returns 订单管理 SDK 单一实例
     */
    getOrder(): IarOrder;
    /**
     * 获取抽奖隐私协议的数据
     * @version v1.4.0
     */
    getLotteryPrivacyDetail(): LotteryPrivacyDetail;
    /**
     * 解析商品详情
     * @deprecated 从 v2.6.0 版本开始废弃
     * @version v1.11.0
     */
    parseProductDetail(productGoodData: ProductGoodData): Promise<ParseProductDetail>;
    /**
     * 获取投票设置
     * @returns 投票设置，如果不存在则返回 null
     */
    getVoteSetting(): InteractionVoteSetting | null;
    /**
     * @internal
     * @ignore
     */
    destroy(): void;
}

declare class PlvInteractReceiveRebuild extends ModuleBase {
    private __iarCore?;
    /**
     * 获取互动接收端核心对象
     * @internal
     * @ignore
     * @param check 无需检查 `window.PolyvIRSDK` 的存在
     * */
    getIarCoreV2(check?: true): PolyvInteractionCore.InteractionCore;
    getIarCoreV2(check?: false): PolyvInteractionCore.InteractionCore | undefined;
    /**
     * 是否支持回放中用 fakeSocket 来监听事件，替代原本的实时 socket
     * @internal
     * @ignore
     */
    supportReplayFakeSocketListenEnabled(): boolean;
    /**
     * 实例化 V2 core
     */
    protected _initV2Core(): Promise<void>;
    /**
     * 设置 V2 core
     */
    protected _setupV2Core(): void;
    /** 答题卡 SDK 实例 */
    private __iarAnswerCard;
    /**
     * 获取答题卡 SDK 单一实例（V2）
     */
    getAnswerCardV2(): Promise<PolyvAnswerCard.AnswerCard>;
    /** 问卷 SDK 实例 */
    private __iarQuestionnaire;
    /**
     * 获取问卷 SDK 单一实例（V2）
     */
    getQuestionnaireV2(): Promise<PolyvQuestionnaire.Questionnaire>;
    private __iarCheckIn;
    /**
     * 获取签到 SDK 单一实例（V2）
     */
    getCheckInV2(): Promise<PolyvCheckIn.CheckIn>;
    private __iarLottery;
    /**
     * 获取抽奖 SDK 单一实例（V2）
     */
    getLotteryV2(): Promise<PolyvLottery.Lottery>;
    /** 优惠券 SDK 实例 */
    private __iarCoupon;
    /**
     * 获取优惠券 SDK 单一实例（V2）
     */
    getCouponV2(): Promise<PolyvCoupon.Coupon>;
    private __iarLuckyLottery;
    /**
     * 获取平台抽奖 SDK 单一实例
     */
    getLuckyLotteryV2(): Promise<PolyvLuckyLottery.LuckyLottery>;
    private __iarLuckyBag;
    /**
     * 获取福袋 SDK 单一实例（V2）
     */
    getLuckyBagV2(): Promise<PolyvLuckyBag.LuckyBag>;
    private __iarVote;
    /**
     * 获取投票 SDK 单一实例（V2）
     */
    getVoteV2(): Promise<PolyvVote.Vote>;
    private __iarBulletin;
    /**
     * 获取公告 SDK 单一实例（V2）
     */
    getBulletinV2(): Promise<PolyvBulletin.Bulletin>;
}

/**
 * 通过 setTimeout 和递归来模拟 setInterval
 */
export declare function plvInterval(fn: AnyFunc, intervalTime: number | (() => number), options?: {
    maxCount?: number;
    immediate?: boolean;
}): {
    clear: () => void;
};

/**
 * 通过 setTimeout 和递归来模拟 setInterval
 */
declare function plvInterval_2(fn: (...arg: unknown[]) => unknown, intervalTime: number | (() => number), options?: {
    maxCount?: number;
    immediate?: boolean;
}): {
    clear: () => void;
};

/**
 * 邀请模块
 * @class
 */
export declare class PlvInviteModule extends ModuleBase {
    /**
     * 邀请模块事件触发器
     * @version v0.12.0
     * */
    eventEmitter: EventEmitter<InviteEventsRelations, InviteEvents>;
    /** 邀请模块 socket 服务 */
    private __inviteSocketService;
    /** 受邀者ID  */
    private __invitee?;
    /** 获取受邀者ID */
    getInvitee(): string | undefined;
    /** 邀请海报唯一ID */
    private __invitePosterId?;
    /** 获取邀请海报唯一ID */
    getInvitePosterId(): string | undefined;
    /** 企微邀请的员工ID */
    private __wxInviteId?;
    /** 获取企微邀请的员工ID */
    getWorkWxInviteId(): string | undefined;
    /**
     * 邀请者信息
     * @desc 邀请者为最初生成海报进行分享的观众，后续通过海报生成的连接进入直播间的观众，再进行生成海报进行分享，邀请者也不会变化
     * */
    private __inviteUserInfo?;
    /**
     * 获取邀请者信息
     */
    getInviteUserInfo(check?: true): ChannelDetailViewerInviteUser;
    getInviteUserInfo(check?: false): ChannelDetailViewerInviteUser | undefined;
    /**
     * 设置邀请者信息
     * @param userInfo 新的用户信息
     */
    updateInviteUserInfo(userInfo: Partial<ChannelDetailViewerInviteUser>): void;
    /**
     * 生成默认的邀请有礼活动信息
     * @version v1.2.0
     */
    static generateDefaultInviteActivityInfo(): InviteActivityInfo;
    /** 邀请有礼活动信息 */
    private __inviteActivityInfo;
    private __setupInviteActivityInfo;
    /**
     * @internal
     * @ignore
     * @version v0.12.0
     */
    updateInviteActivityInfo(info: Partial<InviteActivityInfo>): void;
    /**
     * 获取邀请有礼活动信息
     * @version v0.12.0
     */
    getInviteActivityInfo(): InviteActivityInfo;
    constructor(_watchCore: PolyvWatchCore);
    updateAppConfig(appConfig: Partial<AppConfig>): void;
    /**
     * 邀请模块初始化
     * @internal
     * @ignore
     * */
    setup(): void;
    /**
     * @internal
     * @ignore
     */
    bindSocketEvents(): void;
    /**
     * 获取"是否可以使用邀请海报"
     * */
    getInvitePosterEnabled(): boolean;
    /**
     * 获取"是否可以使用邀请榜"
     * @version v0.9.0
     * */
    getInviteRankEnabled(): boolean;
    /**
     * 获取邀请榜列表配置信息
     * @version v1.3.0
     */
    getInviteRankSettingInfo(): InviteListSetting;
    /**
     * 获取邀请海报选择页地址
     */
    getInviteGeneratePosterUrl(options?: GeneratePosterUrlOptions): string;
    /**
     * 获取邀请海报地址
     * @version v1.1.0
     */
    getInvitePosterUrl<T extends object = object>(params?: T): string;
    /**
     * 获取排行榜列表
     */
    getRankList(params?: GetRankListParams): Promise<CommonResult<InviteRankRequestFailReason, PageContent<InviteRankItem>>>;
    /**
     * 获取当前用户的排行榜信息
     */
    getCurrentRankInfo(): Promise<InviteRankCurrentViewer | null>;
    /**
     * 获取邀约明细开关是否启用
     * @version v0.8.0
     */
    getInviteDetailEnabled(): boolean;
    /**
     * 获取当前用户的邀请详情分页数据
     * @version v0.8.0
     */
    getInviteDetailList(params?: GetInviteDetailListParams): Promise<CommonResult<InviteDetailListRequestFailReason, PageContent<InviteDetailListItem>>>;
    /**
     * 获取邀请海报数据
     * @version v0.10.0
     */
    getInvitePosterData(): Promise<InvitePosterData>;
    /**
     * 获取邀请有礼奖品列表
     *
     * 需要先通过 {@link getInviteActivityInfo} 获取到邀请有礼活动信息后，判断活动开启后才能正常使用
     * @version v0.12.0
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const inviteActivityInfo = watchCore.invite.getInviteActivityInfo();
     * if (inviteActivityInfo.enabled) {
     *   const prizeList = await watchCore.invite.getInvitePrizeList();
     *   console.info('奖品列表', prizeList);
     * }
     * ```
     */
    getInvitePrizeList(): Promise<InvitePrizeItem[]>;
    /** 获取邀请有礼奖品 */
    private __getInvitePrizeItem;
    /**
     * 获取当前邀请有礼中奖信息
     *
     * 需要先通过 {@link getInviteActivityInfo} 获取到邀请有礼活动，判断活动状态已结束时才去获取
     *
     * @version v0.12.0
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const inviteActivityInfo = watchCore.invite.getInviteActivityInfo();
     * if (inviteActivityInfo.status === InviteActivityStatus.End) {
     *   const prizeWinnerInfo = await watchCore.invite.getInvitePrizeWinnerInfo();
     *   console.info('中奖信息', prizeWinnerInfo);
     * }
     * ```
     */
    getInvitePrizeWinnerInfo(): Promise<InvitePrizeWinnerInfo | null>;
    /**
     * 保存邀请有礼领奖表单数据
     *
     * 需要先使用 {@link getInvitePrizeWinnerInfo} 获取到中奖信息，判断中奖领取类型为 {@link InvitePrizeReceiveType.Form} 才可使用
     * @version v0.12.0
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const prizeWinnerInfo = await watchCore.invite.getInvitePrizeWinnerInfo();
     * if (prizeWinnerInfo && prizeWinnerInfo.receiveType === InvitePrizeReceiveType.Form) {
     *   await watchCore.invite.saveInvitePrizeReceiveForm({
     *      id: prizeWinnerInfo.id,
     *      formData: []  // 请根据 prizeWinnerInfo.receiveInfo.formInfo 处理表单
     *   });
     * }
     * ```
     */
    saveInvitePrizeReceiveForm(options: InvitePrizeReceiveFormCollectParams): Promise<void>;
    /**
     * 获取"是否可以使用邀请明细下载"
     * @version v1.5.0
     */
    getInviteDetailExportEnabled(): boolean;
    /**
     * 开始下载明细
     * @version v1.5.0
     */
    startLoadInviteDetail(): Promise<InviteDetailLoadStatusData>;
    /**
     * 获取下载状态相关信息
     *
     * * @example
     * ```js
     * const watchCore = getWatchCore();
     * const inviteDetailLoadStatusInfo = watchCore.invite.getInviteDetailLoadStatusInfo();
     * if (inviteDetailLoadStatusInfo.type === InviteDetailLoadStatus.UnInit) {
     *   console.info('去点击下载按钮, 开始下载任务');
     * }
     *
     * if (inviteDetailLoadStatusInfo.type === InviteDetailLoadStatus.Loading) {
     *   console.info('邀请明细数据正在下载中, 请稍等');
     * }
     *
     * if (inviteDetailLoadStatusInfo.type === InviteDetailLoadStatus.Complete) {
     *   console.info('邀请明细数据下载完成, 去保存');
     *   a.href = inviteDetailLoadStatusInfo.content;
     * }
     *
     * if (inviteDetailLoadStatusInfo.type === InviteDetailLoadStatus.Error) {
     *   const defaultErrorToastText = '邀请明细数据下载中途发生错误, 请重新下载';
     *   console.info(inviteDetailLoadStatusInfo.content || defaultErrorToastText);
     * }
     * ```
     *
     * @version v1.5.0
     */
    getInviteDetailLoadStatusInfo(): Promise<InviteDetailLoadStatusData>;
    /**
     * @internal
     * @ignore
     */
    destroy(): void;
}

/**
 * 直播预约模块
 * @class
 */
export declare class PlvLiveBookingModule extends ModuleBase {
    /**
     * 生成默认的直播预约配置
     * @version v1.2.0
     */
    static generateDefaultLiveBookingConfig(): LiveBookingConfig;
    /**
     * 获取直播预约配置
     *
     * 从 v1.2.0 开始可以通过 `PlvLiveBookingModule.generateDefaultLiveBookingConfig()` 来获取默认配置
     */
    getLiveBookingConfig(): LiveBookingConfig;
    /**
     * 获取其他直播预约配置
     *  @version v2.0.0
     */
    getOtherLiveBookingConfig(): OtherChannelBookingConfig;
    /**
     * 提交短信直播预约
     * @api
     */
    submitSmsLiveBooking(options: SubmitSmsLiveBookingOptions): Promise<LiveBookingResult>;
    /**
     * 取消直播预约
     * @api
     */
    cancelSmsLiveBooking(options: CancelSmsLiveBookingOptions): Promise<LiveBookingResult>;
    /**
     * 提交微信直播预约
     * @api
     */
    submitWxLiveBooking(options?: WxLiveBookingOptions): Promise<LiveBookingResult>;
    /**
     * 取消微信直播预约
     * @api
     * @version v2.7.0
     */
    cancelWxLiveBooking(options?: WxLiveBookingOptions): Promise<LiveBookingResult>;
    /**
     * 提交自定义预约
     * @api
     * @version v2.7.0
     */
    submitCustomLiveBooking(options?: SubmitCustomLiveBookingOptions): Promise<LiveBookingResult>;
    /**
     * 取消自定义预约
     * @api
     */
    cancelCustomLiveBooking(options?: CancelCustomLiveBookingOptions): Promise<LiveBookingResult>;
}

export declare class PlvLoggerModule extends ModuleBase {
    private __elog?;
    /**
     * 初始化日志模块
     */
    setup(): void;
    /**
     * 监听事件
     */
    private __listenEvents;
    /**
     * 取消事件监听
     */
    private __unlistenEvent;
    /**
     * 设置日志配置
     */
    setLoggerConfig(): void;
    /**
     * 构建日志信息
     * @param type 类型
     * @param module 模块
     * @param title 标题
     * @param content 内容
     */
    private __buildLogMessage;
    /**
     * 上报 log 级别事件
     * @api
     * @param module 模块
     * @param title 标题
     * @param content 内容
     */
    log(module: string, title: string, content?: string): void;
    /**
     * 上报 info 级别事件
     * @api
     * @param module 模块
     * @param title 标题
     * @param content 内容
     */
    info(module: string, title: string, content?: string): void;
    /**
     * 上报 warn 级别事件
     * @api
     * @param module 模块
     * @param title 标题
     * @param content 内容
     */
    warn(module: string, title: string, content?: string): void;
    /**
     * 上报 error 级别事件
     * @api
     * @param module 模块
     * @param title 标题
     * @param content 内容
     */
    error(module: string, title: string, content?: string): void;
    destroy(): void;
}

export declare class PlvMarqueeModule extends ModuleBase {
    eventEmitter: EventEmitter<MarqueeEventsRelations, MarqueeEvents>;
    /**
     * 当前创建的跑马灯实例对象
     */
    private __marqueeTargets;
    /**
     * 当前跑马灯数据
     */
    private __currentMarqueeData?;
    /**
     * 获取跑马灯设置信息
     * @internal
     * @ignore
     */
    getMarqueeSetting(): MarqueeSetting;
    /**
     * 获取播放器回调的跑马灯数据
     * @internal
     * @ignore
     */
    getMarqueeData(): MarqueeData | undefined;
    /**
     * 设置跑马灯数据
     * @internal
     * @ignore
     * @param marqueeData 跑马灯数据
     */
    setMarqueeData(marqueeData: MarqueeData): void;
    /**
     * 触发检查错误钩子
     * @dec code 参考播放器错误码 {@link https://help.polyv.net/index.html#/live/js/live_player/api}
     * @internal
     * @ignore
     */
    emitCheckError(params?: {
        code: 'LIVE-#022' | 'LIVE-#012';
    }): void;
    /**
     * 创建跑马灯
     * @internal
     * @ignore
     */
    createMarquee(options: SetupMarqueeOptions): MarqueeTarget;
    /**
     * 处理设置昵称事件
     */
    private __onSetNick;
    /**
     * 监听设置昵称事件
     */
    private __listenSetNickEvents;
    /**
     * 取消事件监听
     */
    private __unlistenSetNickEvents;
    /**
     * @internal
     * @ignore
     */
    destroy(): void;
}

/**
 * @class 频道菜单模块
 */
export declare class PlvMenuModule extends ModuleBase {
    /** 事件触发器 */
    eventEmitter: EventEmitter<MenuEventsRelations, MenuEvents>;
    /** 菜单 Socket 服务实例 */
    private __menuSocketService;
    /** 频道中文菜单 */
    private __cnChannelMenus;
    /** 频道英文菜单 */
    private __enChannelMenus;
    /**
     * 设置频道详情
     */
    setup(): void;
    /**
     * @internal
     * @ignore
     */
    bindSocketEvents(): void;
    /**
     * 设置频道菜单列表
     * @param menus 新的频道菜单列表
     * @param type 类型，中文或英文
     */
    private __resetChannelMenus;
    /**
     * 获取频道菜单列表
     * @param type 类型，中文或英文
     */
    getChannelMenus(type?: LanguageType): ChannelMenuItem[];
    /**
     * 插入频道菜单
     * @param menuData 菜单数据
     * @param onlyType 是否唯一的 menuType
     */
    addChannelMenu(menuData: ChannelMenuItem, onlyType?: boolean): void;
    /**
     * 移除菜单
     * @param menuId 菜单 id
     * @param menuType 菜单类型
     */
    removeChannelMenu(menuId: string, menuType?: ChannelMenuType): void;
    /**
     * 更新菜单数据
     * @internal
     * @ignore
     * @param menuData 菜单对象
     */
    updateChannelMenu(menuData: ChannelMenuItem): void;
    /**
     * 获取中文菜单节点
     * @internal
     * @ignore
     * @param menuId 菜单 id
     * @param type 类型，中文或英文
     */
    getChannelMenuItem(menuId: string, type?: LanguageType): ChannelMenuItem | undefined;
    /**
     * 是否存在实时更新的自定义图文菜单
     * @internal
     * @ignore
     * @param type 类型，中文或英文
     */
    isExistRealTimeFlushTextMenu(type?: LanguageType): boolean;
    /**
     * 获取频道菜单内容
     * @internal
     * @ignore
     */
    getChannelMenuContent(params: GetChannelMenuDataParams): Promise<string>;
    destroy(): void;
}

/**
 * {@link https://wiki.igeeker.org/pages/viewpage.action?pageId=461526879 微活动-接入嗨现场文档记录 }
 */
/**
 * 微活动模块
 * @class
 */
export declare class PlvMicroActivityModule extends ModuleBase {
    /**
     * 获取微活动需要跳转的 iframe 链接
     * @api
     */
    getMicroActivityUrl(): Promise<string>;
    /**
     * 获取微活动设置
     */
    getMicroActivitySetting(): MicroActivitySetting;
}

/**
 * 分会场模块
 * @class
 */
export declare class PlvMultiMeetingModule extends ModuleBase {
    /**
     * 是否需要跳转回分会场
     */
    private __subMeetingChannelRedirect;
    /**
     * 跳转回分会场时的频道号
     */
    private __redirectSubChannelId?;
    setup(): void;
    /**
     * 获取当前是否需要跳转回分会场
     */
    getRedirectSubChannelData(): RedirectSubChannelData;
    /**
     * 生成分会场观看页地址
     * @api
     * @param channelId 频道号
     */
    generateMultiMeetingWatchUrl(channelId: string): string;
    /**
     * 获取默认的分会场设置
     * @version v1.2.0
     */
    static generateDefaultMultiMeetingSetting(): MultiMeetingSetting;
    /**
     * 获取分会场设置
     *
     * 从 v1.2.0 开始可以通过 `PlvMultiMeetingModule.generateDefaultMultiMeetingSetting()` 来获取默认配置
     */
    getMultiMeetingSetting(): MultiMeetingSetting;
    /**
     * 获取主会场频道号
     * @api
     */
    getMainChannelId(): string | undefined;
    /**
     * 分页获取分会场列表
     */
    getMultiMeetingList(options?: GetMultiMeetingListOptions): Promise<PageContent<MultiMeetingItem>>;
    /**
     * 获取分会场的直播状态
     * @api
     */
    getMultiMeetingLiveStatus(): Promise<MultiMeetingLiveStatusData[]>;
}

/**
 * 订单模块
 * @class
 * @deprecated 从 v2.6.0 版本开始废弃
 * @version v1.5.0
 */
export declare class PlvOrderModule extends ModuleBase {
    /**
     * 创建商品订单
     */
    createOrder(options: CreateOrderParams): Promise<CreateOrderResponse>;
    /**
     * 商品订单发起支付
     */
    orderPay(orderNo: string): Promise<CreateOrderResponse>;
    /**
     * 商品订单发起支付
     * @version v2.2.0
     */
    orderPayWithPayProvider(options: OrderPayParams): Promise<CreateOrderResponse>;
    /**
     * 检测当前环境&观看条件下, 商品是否可点击购买
     */
    checkPurchasable(): boolean;
    /**
     * 获取"是否可以展示订单中心"
     * */
    getOrderEnabled(): boolean;
    /** 支付方式缓存 */
    private __payProviderCache;
    /**
     * 获取支持的支付方式
     * @version v2.2.0
     * @desc 这里支持缓存是因为一般支付方式不会改动，但是需要获取支付方式的入口可能会有多个，又不想页面加载时请求这个接口，所以这里支持缓存。
     */
    getPayProviders(options: {
        useReqCache?: boolean;
    }): Promise<PayProvider[]>;
    /**
     * 获取订单详情
     * @version v2.2.0
     */
    getOrderDetail(params: GetOrderDetailParams): Promise<OrderDetailData>;
}

/** 转换 JSON 字符串成对象 */
export declare function plvParseJson<T>(params: string): {
    success: true;
    data: T;
} | {
    success: false;
    data: string;
};

/** 转换 JSON 字符串成对象 */
declare function plvParseJson_2<T>(params: string): {
    success: true;
    data: T;
} | {
    success: false;
    data: string;
};

/**
 * 回放模块
 * @class
 */
export declare class PlvPlaybackModule extends ModuleBase {
    /**
     * 事件触发器，用于发布和订阅回放模块相关事件
     * @version v0.9.0
     */
    eventEmitter: EventEmitter<PlaybackEventsRelations, PlaybackEvents>;
    /**
     * 获取回放信息
     */
    private __getPlaybackInfo;
    /**
     * 当前的回放对象
     */
    private __currentPlaybackTarget;
    /**
     * 设置当前的回放对象
     * 设置后会自动触发 CurrentPlaybackTargetUpdated 事件
     * @param target 回放对象，为 undefined 时可清除当前回放对象
     * @version v0.9.0
     * @example
     * ```js
     * const watchCore = getWatchCore();
     *
     * // 设置当前回放对象
     * watchCore.playback.setCurrentPlaybackTarget(playbackTarget);
     *
     * // 清除当前回放对象
     * watchCore.playback.setCurrentPlaybackTarget(undefined);
     * ```
     */
    setCurrentPlaybackTarget(target?: PlaybackTarget): void;
    /**
     * 获取当前的回放对象
     * @return 当前设置的回放对象，未设置时返回 undefined
     * @version v0.10.0
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const target = watchCore.playback.getCurrentPlaybackTarget();
     * if (target) {
     *   console.log('当前回放标题:', target.title);
     * }
     * ```
     */
    getCurrentPlaybackTarget(): PlaybackTarget | undefined;
    /**
     * 获取当前的回放方式
     * 根据频道配置和进入方式判断是单个回放还是列表回放
     * @return 回放方式，单个回放或列表回放
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const mode = watchCore.playback.getCurrentPlaybackMode();
     * if (mode === PlaybackMode.Single) {
     *   // 单个回放模式
     *   const target = watchCore.playback.getSinglePlaybackTarget();
     * } else {
     *   // 列表回放模式
     *   const list = await watchCore.playback.getPlaybackList();
     * }
     * ```
     */
    getCurrentPlaybackMode(): PlaybackMode;
    /**
     * 过滤回放文件为播放器回放参数
     * @param recordFile 回放文件
     */
    private __getPlaybackOptionByRecord;
    /**
     * 过滤回放（回放列表）为播放器回放参数
     * @param target 回放对象
     */
    private __getPlaybackOptionByPlayback;
    /**
     * 过滤回放（点播列表）为播放器回放参数
     * @param target 回放对象
     */
    private __getPlaybackOptionByVod;
    /**
     * 过滤回放（素材库）为播放器回放参数
     * @param target 回放对象
     */
    private __getPlaybackOptionByMaterial;
    /**
     * 过滤回放文件
     * @param recordFile 回放文件
     */
    private __filterRecordFile;
    /**
     * 过滤回放对象
     * @param target 回放对象
     * @param playbackType 回放源
     */
    private __filterPlaybackVideoTarget;
    /**
     * 获取"单个视频"回放对象
     * 根据频道配置获取当前频道的回放信息，转换为回放目标对象
     * @return 回放目标对象，如果频道没有回放配置则返回 undefined
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const target = watchCore.playback.getSinglePlaybackTarget();
     * if (target) {
     *   watchCore.playback.setCurrentPlaybackTarget(target);
     *   watchCore.player.setupPlayer({
     *     container: document.getElementById('player'),
     *     playbackOptions: target.playbackOptions,
     *   });
     * }
     * ```
     */
    getSinglePlaybackTarget(): PlaybackTarget | undefined;
    /**
     * 获取回放列表
     * 从接口获取分页的回放列表数据，从 v2.14.0 版本开始支持传入 keyword 参数来搜索视频
     *
     * @param params 分页参数，包括 pageNumber 和 pageSize，不传则使用默认值(1, 10)
     * @return 回放列表分页数据
     * @example
     * ```js
     * const watchCore = getWatchCore();
     *
     * // 获取第一页，每页10条
     * const list = await watchCore.playback.getPlaybackList();
     *
     * // 自定义分页
     * const list = await watchCore.playback.getPlaybackList({
     *   pageNumber: 1,
     *   pageSize: 20,
     * });
     *
     * console.log('总数量:', list.totalElements);
     * list.contents.forEach(item => {
     *   console.log('回放标题:', item.title);
     * });
     * ```
     */
    getPlaybackList(params?: GetPlaybackListParams): Promise<PageContent<PlaybackTarget>>;
    /**
     * 根据回放id获取回放对象
     * 通过回放ID从接口获取单个回放目标对象
     * @param opts 回放ID参数对象，包含 playbackId 字段
     * @return 回放目标对象
     * @version v2.0.0
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const target = await watchCore.playback.getPlaybackTargetById({
     *   playbackId: 'xxx',
     * });
     * watchCore.playback.setCurrentPlaybackTarget(target);
     * await watchCore.player.changePlayback(target.playbackOptions);
     * ```
     */
    getPlaybackTargetById(opts: {
        playbackId: string;
    }): Promise<PlaybackTarget>;
    /**
     * 获取初始回放来源
     * @version v2.0.0
     * @internal
     * @ignore
     */
    getOriginPlaybackType(): PlaybackType;
    /**
     * 获取回放来源
     * @version v2.0.0
     * @internal
     * @ignore
     */
    getPlaybackType(): PlaybackType;
    /**
     * 获取"是否显示章节"
     * @return 是否显示章节功能
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const enabled = watchCore.playback.getChapterEnabled();
     * if (enabled) {
     *   // 显示章节列表
     *   const playbackTarget = watchCore.playback.getCurrentPlaybackTarget();
     *   if (playbackTarget) {
     *     const chapters = await watchCore.playback.getChapterList(playbackTarget.playbackOptions);
     *   }
     * }
     * ```
     */
    getChapterEnabled(): boolean;
    /**
     * 获取章节列表
     * 根据回放选项获取对应的章节数据
     * @param playbackOptions 回放参数，从 PlaybackTarget.playbackOptions 获取
     * @return 章节列表数组
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const playbackTarget = watchCore.playback.getCurrentPlaybackTarget();
     *
     * if (playbackTarget) {
     *   const chapters = await watchCore.playback.getChapterList(playbackTarget.playbackOptions);
     *   chapters.forEach(chapter => {
     *     console.log('章节标题:', chapter.title);
     *     console.log('章节时长:', chapter.duration);
     *   });
     * }
     * ```
     */
    getChapterList(playbackOptions: SetupPlayerPlaybackOptions): Promise<ChapterItem[]>;
    /**
     * 获取智能大纲数据
     * 从指定URL获取AI生成的回放大纲数据
     * @param url 大纲数据JSON地址，从 PlaybackTarget.outline.outlineUrl 获取
     * @return 智能大纲数据对象
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const playbackTarget = watchCore.playback.getCurrentPlaybackTarget();
     *
     * if (playbackTarget?.outline?.outlineUrl) {
     *   const outline = await watchCore.playback.getOutlineList(playbackTarget.outline.outlineUrl);
     *   console.log('大纲数据:', outline);
     * }
     * ```
     */
    getOutlineList(url: string): Promise<PlaybackOutlineData>;
    /**
     * 获取知识检测数据
     * 从指定URL获取AI生成的知识检测/互动答题数据
     * @param url 知识检测数据JSON地址，从 PlaybackTarget.outline.questionUrl 获取
     * @return 知识检测数据对象
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const playbackTarget = watchCore.playback.getCurrentPlaybackTarget();
     *
     * if (playbackTarget?.outline?.questionUrl) {
     *   const questions = await watchCore.playback.getQuestionList(playbackTarget.outline.questionUrl);
     *   console.log('问答数据:', questions);
     * }
     * ```
     */
    getQuestionList(url: string): Promise<PlaybackQuestionData>;
    /**
     * 获取逐字稿数据
     * 从指定URL获取AI生成的字幕逐字稿数据，依赖 AI-SDK
     *
     * @param url 字幕数据JSON地址，从 PlaybackTarget.subtitleList 中找到 isOriginal 为 'Y' 的字幕的 srtUrl
     * @return 逐字稿列表
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const playbackTarget = watchCore.playback.getCurrentPlaybackTarget();
     *
     * if (playbackTarget?.subtitleList) {
     *   // 找到原声字幕
     *   const originSubtitle = playbackTarget.subtitleList.find(i => i.isOriginal === 'Y');
     *   if (originSubtitle?.srtUrl) {
     *     const subtitles = await watchCore.playback.getAiSubtitleList(originSubtitle.srtUrl);
     *     subtitles.forEach(item => {
     *       console.log('时间点:', item.time);
     *       console.log('内容:', item.text);
     *     });
     *   }
     * }
     * ```
     */
    getAiSubtitleList(url: string): Promise<AISubtitleParsedItem[]>;
    /**
     * 获取"是否支持快进快退"
     * 判断当前频道和回放是否支持快进快退功能
     * @return 是否支持快进快退
     * @version v1.9.2
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const enabled = watchCore.playback.getFastForwardBackwardEnabled();
     * console.log('支持快进快退:', enabled);
     * ```
     */
    getFastForwardBackwardEnabled(): boolean;
    /**
     * 是否支持商品库回放
     */
    private __getProductReplayEnabled;
    /**
     * 获取是否支持循环播放
     * 判断当前频道回放是否支持循环播放功能
     * @return 是否支持循环播放
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const enabled = watchCore.playback.getLoopPlayEnabled();
     * if (enabled) {
     *   // 显示循环播放按钮
     * }
     * ```
     */
    getLoopPlayEnabled(): boolean;
    /**
     * 获取是否展示回放列表开始时间
     * 判断回放列表是否显示直播开始时间
     * @return 是否展示回放列表开始时间
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const enabled = watchCore.playback.getListLiveStartTimeEnabled();
     * console.log('展示开始时间:', enabled);
     * ```
     */
    getListLiveStartTimeEnabled(): boolean;
    /**
     * 是否支持连接聊天室
     */
    private __getChatConnectEnabled;
    /**
     * 是否支持重放
     */
    private __getSupportReplay;
    /**
     * 是否支持聊天消息重放
     */
    private __getChatMsgReplayEnabled;
    /**
     * 是否支持卡片推送重放
     */
    private __getCardPushReplayEnabled;
    /**
     * 是否支持签到重放
     */
    private __getCheckInReplayEnabled;
    /**
     * 是否支持答题卡重放
     */
    private __getAnswerCardReplayEnabled;
    /**
     * 是否支持问卷重放
     */
    private __getQuestionnaireReplayEnabled;
    /**
     * 获取"是否可以聊天重放"
     */
    private __getChatReplayEnabled;
    /**
     * 格式化后端的首帧图字段
     * @param firstImage 首帧图
     */
    private __formatFirstImage;
    /**
     * 格式化 videoPoolId 为 vid
     * @param videoPoolId 点播视频 id
     */
    private __formatVid;
    /**
     * 格式化 videoId
     */
    private __formatVideoId;
    /**
     * 格式化后端的开始时间字段
     * @param startTime 后端返回的开始时间
     */
    private __formatStartTime;
    /**
     * 根据回放视频来源数据，推算回放视频类型
     * @param origin 回放视频来源
     */
    private __formatPlaybackTypeByOrigin;
    /**
     * @internal
     * @ignore
     */
    destroy(): void;
}

/**
 * 播放器模块
 * @class
 */
export declare class PlvPlayerModule extends ModuleBase {
    /** 播放器事件触发器 */
    eventEmitter: EventEmitter<PlayerEventsRelations, PlayerEvents>;
    /** 时移服务 */
    private __timeShiftService;
    /** 模块事件绑定服务 */
    private __bindModuleEventServices;
    /**
     * 获取时移服务
     * @ignore
     * @internal
     */
    getTimeShiftService(): TimeShiftService;
    /**
     * 生成默认的播放器信息
     * @version v1.2.0
     */
    static generateDefaultPlayerInfo(): PlayerStoreInfo;
    /** 播放器信息 */
    private __playerInfo;
    /**
     * 获取播放器信息
     *
     * 播放器模块会保存播放器的状态信息，通过 `getPlayerInfo` 方法获取当前播放的所有状态。
     * @example
     * ```js
     * const playerInfo = watchCore.player.getPlayerInfo();
     * console.log('播放状态', playerInfo.playStatus); // playing or pause
     * console.log('是否支持无延迟', playerInfo.supportLowLatency);
     * console.log('是否无延迟', playerInfo.isLowLatency);
     * ```
     */
    getPlayerInfo(): PlayerStoreInfo;
    /**
     * 设置播放器信息
     * @internal
     * @ignore
     */
    updatePlayerInfo(info: Partial<PlayerStoreInfo>): void;
    /**
     * 获取直播播放器的统计 param
     * @internal
     * @ignore
     * @warn low-latency-player 也用到这个方法
     */
    getLivePlayerStatParams(): PlayerLiveStatParams;
    /**
     * 获取点播播放器的统计 param
     * @internal
     * @ignore
     */
    getVodPlayerStatParams(): VodPlayerStatistics;
    /** 播放器选项辅助工具 */
    private __playerOptionHelper;
    /** 当前创建的播放器控制器 */
    private __playerCtrl?;
    /** 当前播放器的设置选项 */
    private __currentOptions?;
    /** 当前播放器的回放设置选项 */
    private __currentPlaybackOptions?;
    /**
     * 获取当前播放器的设置选项
     * @internal
     * @ignore
     */
    getCurrentOptions(): SetupPlayerOptions | undefined;
    /**
     * 获取当前播放器的回放设置选项
     * @internal
     * @ignore
     */
    getCurrentPlaybackOptions(): SetupPlayerPlaybackOptions | undefined;
    constructor(_watchCore: PolyvWatchCore);
    /**
     * 获取后台配置的播放器比例
     */
    private __getPlayerResolutionRatio;
    /**
     * 获取竖屏播放器画面适配类型
     */
    private __getPortraitPlayerScreenType;
    /**
     * 根据接口配置来设置播放器信息
     */
    private __setupPlayerInfo;
    /**
     * 根据接口配置来设置暖场配置
     */
    private __setupWarmupSetting;
    /**
     * 播放器模块初始化
     * @internal
     * @ignore
     */
    setup(): void;
    /**
     * 创建播放器
     *
     * 通过 `setupPlayer` 创建观看页的播放器。
     *
     * `lowLatency` 参数负责控制播放器是否使用无延迟播放，开启后若当前为无延迟频道并且设备支持无延迟播放则使用无延迟进行播放，开发者可通过 {@link supportLowLatency} 方法判断当前环境和频道是否支持无延迟。
     *
     * 通过 {@link PlayerEvents.PlayerInited} 监听播放器创建并初始化完成事件，当触发该事件后即可调用播放器模块的其他方法，如：{@link play}、{@link pause}。
     * @param options 创建参数
     * @example
     * ```js
     * await watchCore.player.setupPlayer({
     *   container: 'NodeElement',
     *   lowLatency: true, // 使用无延迟播放
     * });
     * ```
     */
    setupPlayer(options: SetupPlayerOptions): Promise<void>;
    /**
     * 获取播放器视频元素
     * @internal
     * @ignore
     * */
    getPlayerVideoElement(): HTMLVideoElement | undefined;
    /**
     * 播放器初始化完成事件回调之前处理
     * @internal
     * @ignore
     */
    beforePlayerInited(): void;
    /**
     * 移动端是否显示倍速按钮
     */
    private __supportMobileSpeed;
    /**
     * 是否支持直播时移
     *
     * 通过 `supportLiveTimeShift` 获取播放器否支持直播时移
     * @category 时移打点
     * @version v0.5.0
     * @example
     * ```js
     * const supportResult = watchCore.player.supportLiveTimeShift();
     * if (supportResult.support) {
     *   console.log('支持直播时移');
     * } else {
     *   console.log('不支持直播时移');
     * }
     * ```
     */
    supportLiveTimeShift(): SupportResult;
    /**
     * 是否支持时间轴标记
     *
     * 通过 `supportTimeAxisMark` 获取播放器是否支持时间轴标记。注意，直播打点需要直播时移也开启了，才能正常返回 true
     * @category 时移打点
     * @version v0.5.0
     * @example
     * ```js
     * const supportResult = watchCore.player.supportTimeAxisMark();
     * if (supportResult.support) {
     *   console.log('支持时间轴标记');
     * } else {
     *   console.log('不支持时间轴标记');
     * }
     * ```
     */
    supportTimeAxisMark(): SupportResult;
    /**
     * 获取播放器控制器类
     * 默认返回 LivePlayerController
     */
    private __getPlayerControllerCtor;
    /**
     * 是否支持无延迟观看
     *
     * 通过 `supportLowLatency` 方法获取当前环境和频道是否支持无延迟观看。
     * @category 无延迟
     * @returns 支持结果
     * @example
     * ```js
     * const supportResult = watchCore.player.supportLowLatency();
     * if (supportResult.support) {
     *   console.log('支持无延迟观看');
     * } else {
     *   console.log('不支持无延迟观看');
     * }
     * ```
     */
    supportLowLatency(): SupportResult;
    /**
     * 弹幕添加事件
     */
    private __barrageAddCallback;
    /**
     * 设置自动添加弹幕
     */
    private __setBarrageAutoAdd;
    /**
     * 移除自动添加弹幕
     */
    private __removeBarrageAutoAdd;
    /**
     * 获取播放器控制器
     * @throws 如果未创建则会抛错
     */
    private __getPlayerCtrl;
    /**
     * 获取播放状态
     * @internal
     * @ignore
     */
    getPlayStatus(): PlayStatus;
    /**
     * 恢复视频播放
     *
     * 通过 `play` 方法触发播放器播放直播流或视频。
     * @category 播放/暂停
     * @example
     * ```js
     * // 恢复播放
     * watchCore.player.play();
     * ```
     */
    play(): void;
    /**
     * 冻结视频播放
     *
     * @version v1.3.0
     *
     * 可通过 `freezePlay` 方法来冻结播放器，不允许播放器执行播放操作，当前仅支持部分播放器
     * @category 播放/暂停
     * @example
     * ```js
     * // 冻结播放
     * watchCore.player.freezePlay(true);
     * ```
     */
    freezePlay(isFreeze: boolean): void;
    /**
     * 暂停视频播放
     *
     * 通过 `pause` 方法暂停视频播放。
     * @category 播放/暂停
     * @example
     * ```js
     * // 暂停播放
     * watchCore.player.pause();
     * ```
     */
    pause(): void;
    /**
     * 停止拉流
     *
     * 通过 `stop` 方法停止视频拉流，暂支持无延迟停止拉流
     * 可通过 `play` 方法恢复播放
     * @category 播放/暂停
     * @example
     * ```js
     * // 停止拉流
     * watchCore.player.stop();
     * ```
     */
    stop(): void;
    /**
     * 是否支持刷新
     *
     * 通过 `supportRefresh` 方法判断当前是否支持刷新直播流，判断条件：
     * - 频道正在直播
     * - 播放器初始化完成
     * - 非无延迟频道
     * - 当前用户未连麦
     * @category 刷新
     * @returns 支持结果
     * @example
     * ```js
     * const supportResult = watchCore.player.supportRefresh();
     * if (supportResult.support) {
     *   console.log('支持刷新，显示刷新按钮');
     * } else {
     *   console.log('不支持刷新，隐藏刷新按钮');
     * }
     * ```
     */
    supportRefresh(): SupportResult;
    /**
     * 刷新直播流
     *
     * 通过 `refresh` 刷新当前直播流，注意需要根据 {@link supportRefresh} 方法或 {@link getPlayerInfo} 方法判断是否当前是否支持刷新直播流。
     * @category 刷新
     * @example
     * ```js
     * const playerInfo = watchCore.player.getPlayerInfo();
     * if (playerInfo.supportRefresh) {
     *   watchCore.player.refresh();
     * }
     * ```
     */
    refresh(): void;
    /**
     * 设置视频音量
     *
     * 通过 `setVolume` 方法设置当前播放器视频的音量。
     * @category 音量
     * @param volume 音量，范围：0～1
     * @example
     * ```js
     * // 静音播放器
     * watchCore.player.setVolume(0);
     * // 设为 70% 音量
     * watchCore.player.setVolume(0.7);
     * ```
     */
    setVolume(volume?: number): void;
    /**
     * 获取视频音量
     *
     * 通过 `getCurrentVolume` 获取当前播放器的视频音量，除了该 Api 外你也可以通过 `playerInfo` 获取当前音量。
     * @category 音量
     * @returns 音量，范围：0～1
     * @example
     * ```js
     * // 通过 api 获取
     * const volume = watchCore.player.getCurrentVolume();
     * console.log('当前音量', volume);
     * // 通过状态获取
     * const playerInfo = watchCore.player.getPlayerInfo();
     * console.log('当前音量', playerInfo.currentVolume);
     * ```
     */
    getCurrentVolume(): number;
    /**
     * 添加弹幕
     *
     * 通过 `addBarrage` 添加弹幕，在创建播放器传入 `barrageAutoAdd` 为 true 时，播放器模块会自动监听聊天消息事件，当有观众发言时会自动将消息文本插入到弹幕中。
     * @category 弹幕
     * @param options 弹幕参数
     * @example
     * ```js
     * // 添加弹幕消息
     * watchCore.player.addBarrage({
     *   msg: '今天天气真好',
     * });
     * // 带有表情
     * watchCore.player.addBarrage({
     *   msg: '老师讲的真好[大笑][大笑]',
     * });
     * ```
     */
    addBarrage(options: BarrageAddOptions): void;
    /**
     * 设置弹幕显示状态
     *
     * 创建播放器时传入 `barrageEnabled` 为 true 时，通过 `setBarrageShow` 方法切换弹幕都显示和隐藏状态。
     * @category 弹幕
     * @param show 弹幕显示状态
     * @example
     * ```js
     * // 显示弹幕
     * watchCore.player.setBarrageShow(true);
     * // 隐藏弹幕
     * watchCore.player.setBarrageShow(false);
     * ```
     */
    setBarrageShow(show: boolean): void;
    /**
     * 是否支持弹幕速度切换
     *
     * 通过 `supportBarrageSpeed` 获取播放器是否支持弹幕速度切换。
     * @category 弹幕
     * @example
     * ```js
     * const supportResult = watchCore.player.supportBarrageSpeed();
     * if (supportResult.support) {
     *   console.log('显示弹幕速度切换');
     * } else {
     *   console.log('隐藏弹幕速度切换');
     * }
     * ```
     */
    supportBarrageSpeed(): SupportResult;
    /**
     * 切换弹幕速度
     *
     * 当观众想要显示更快或更慢的弹幕速度时，可调用 `setBarrageSpeed` 设置弹幕滚动速度。
     * 注意播放器模块会记录用户切换的弹幕速度，调用 `setupPlayer` 没有传入 `barrageSpeed` 时会优先使用本地缓存的速度。
     *
     * 注意需要通过 {@link supportBarrageSpeed} 方法获取当前播放器是否支持弹幕速度切换。
     * @warn 弹幕速度值最大不得超过 400
     * @category 弹幕
     * @param speed 弹幕速度
     * @example
     * ```js
     * // 缓慢速度
     * watchCore.player.setBarrageSpeed(340);
     * // 较慢速度
     * watchCore.player.setBarrageSpeed(270);
     * // 标准速度
     * watchCore.player.setBarrageSpeed(200);
     * // 较快速度
     * watchCore.player.setBarrageSpeed(130);
     * // 快速速度
     * watchCore.player.setBarrageSpeed(60);
     * ```
     */
    setBarrageSpeed(speed: number): void;
    /**
     * 是否支持弹幕字号切换
     * @version v0.9.0
     * 通过 `supportBarrageSize` 获取播放器是否支持弹幕速度切换。
     * @category 弹幕
     * @example
     * ```js
     * const supportResult = watchCore.player.supportBarrageSize();
     * if (supportResult.support) {
     *   console.log('显示弹幕字号切换');
     * } else {
     *   console.log('隐藏弹幕字号切换');
     * }
     * ```
     */
    supportBarrageSize(): SupportResult;
    /**
     * 切换弹幕字号
     * @version v0.9.0
     *
     * 当观众想要显示更大或更小的弹幕字号时，可调用 `setBarrageSize` 设置弹幕文本字号。
     * 注意播放器模块会记录用户切换的弹幕字号，调用 `setupPlayer` 没有传入 `barrageSize` 时会优先使用本地缓存的速度。
     *
     * 注意需要通过 {@link supportBarrageSize} 方法获取当前播放器是否支持弹幕字号切换。
     * @category 弹幕
     * @param size 弹幕字号
     * @example
     * ```js
     * // 较小
     * watchCore.player.setBarrageSize(12);
     * // 小
     * watchCore.player.setBarrageSize(16);
     * // 标准
     * watchCore.player.setBarrageSize(20);
     * // 大
     * watchCore.player.setBarrageSize(24);
     * // 较大
     * watchCore.player.setBarrageSize(28);
     * ```
     */
    setBarrageSize(size: number): void;
    /**
     * 是否支持弹幕位置切换
     * @version v0.11.0
     * 通过 `supportBarrageLocation` 获取播放器是否支持弹幕位置切换。
     * @category 弹幕
     * @example
     * ```js
     * const supportResult = watchCore.player.supportBarrageLocation();
     * if (supportResult.support) {
     *   console.log('显示弹幕位置切换');
     * } else {
     *   console.log('隐藏弹幕位置切换');
     * }
     * ```
     */
    supportBarrageLocation(): SupportResult;
    /**
     * 获取弹幕位置信息
     * @version v0.11.0
     * 通过 `getBarrageLocationSetting` 获取播放器支持切换的弹幕位置类型信息。
     * @category 弹幕
     * @example
     * ```js
     * const locationInfo = watchCore.player.getBarrageLocationSetting();
     * locationInfo.forEach(item => {
     *   console.info('位置类型:', item.type, '位置ID:', item.index);
     * });
     * ```
     */
    getBarrageLocationSetting(): BarrageLocationInfo[];
    /**
     * 切换弹幕位置
     * @param index 切换弹幕位置的ID
     * @version v0.11.0
     *
     * 当观众想要弹幕文本区域切换不同位置显示，可调用 `setBarrageLocation` 设置弹幕文本显示区域。
     *
     * 注意：
     * 通过 {@link supportBarrageLocation} 方法获取当前播放器是否支持弹幕位置切换。
     * 通过 {@link getBarrageLocationSetting} 方法获取弹幕位置详细数据，使用返回数据中对应的index参数切换位置。
     *
     * @category 弹幕
     * @param index 弹幕位置ID
     * @example
     * ```js
     * watchCore.player.setBarrageLocation(index);
     * ```
     */
    setBarrageLocation(index: number): void;
    /**
     * 是否支持弹幕透明度切换
     * @version v0.11.0
     * 通过 `supportBarrageAlpha` 获取播放器是否支持弹幕透明度切换。
     * @category 弹幕
     * @example
     * ```js
     * const supportResult = watchCore.player.supportBarrageAlpha();
     * if (supportResult.support) {
     *   console.log('显示弹幕透明度切换');
     * } else {
     *   console.log('隐藏弹幕透明度切换');
     * }
     * ```
     */
    supportBarrageAlpha(): SupportResult;
    /**
     * 切换弹幕透明度
     *
     * 当观众想要弹幕文本显示不同的透明度，可调用 `setBarrageAlpha` 设置弹幕文本的透明度。
     *
     * 注意需要通过 {@link supportBarrageAlpha} 方法获取当前播放器是否支持弹幕透明度切换。
     *
     * @version v0.11.0
     *
     * @category 弹幕
     * @param alpha 切换弹幕透明度, 取值范围0~100
     * @example
     * ```js
     * watchCore.player.setBarrageAlpha(80);
     * ```
     */
    setBarrageAlpha(alpha: number): void;
    /**
     * 更新弹幕显示区域
     *
     * 在点击全屏按钮，实现网页全屏或者css旋转横屏场景下需要更新弹幕区域显示高度
     *
     * @version v1.1.0
     * @category 弹幕
     */
    resizeBarrage(): void;
    /**
     * 获取线路总数
     *
     * 通过 `getLineCount` 获取当前播放器可切换的总线路数，除了该 Api 外你也可以通过 `playerInfo` 获取总线路数。
     * @category 线路
     * @returns 可切换的线路总数
     * @example
     * ```js
     * const lineCount = watchCore.player.getLineCount();
     * console.log('可切换的总线路数', lineCount);
     * // 通过状态获取
     * const playerInfo = watchCore.player.getPlayerInfo();
     * console.log('可切换的总线路数', playerInfo.lineCount);
     * ```
     */
    getLineCount(): number;
    /**
     * 切换线路
     *
     * 当用户点击切换线路时，通过 `changeLine` 方法切换数，线路总数可调用 {@link getLineCount} 获取。
     * @category 线路
     * @param line 线路索引
     * @example
     * ```js
     * // 切换线路1
     * watchCore.player.changeLine(0);
     * // 切换线路2
     * watchCore.player.changeLine(1);
     * ```
     */
    changeLine(line: number): void;
    /**
     * 获取当前线路
     *
     * 通过 `getCurrentLine` 获取当前播放器的线路，除了该 Api 外你也可以通过 `playerInfo` 获取总线路数。
     * @category 线路
     * @returns 当前线路索引（从 0 开始）
     * @example
     * ```js
     * const currentLine = watchCore.player.getCurrentLine();
     * console.log('当前线路索引', currentLine);
     * // 通过状态获取
     * const playerInfo = watchCore.player.getPlayerInfo();
     * console.log('当前线路索引', playerInfo.currentLine);
     * ```
     */
    getCurrentLine(): number;
    /**
     * 改变实时字幕播放器的开关展示
     *
     * 通过 `changeSubtitleSkinShow` 改变实时字幕播放器的开关展示
     *
     * @category 实时字幕
     * @returns void
     * @version v0.7.0
     * @example
     * ```js
     * watchCore.player.changeSubtitleSkinShow(true);
     * ```
     */
    changeSubtitleSkinShow(show: boolean, checked?: boolean): void;
    static QualityLevelType: typeof QualityLevelType;
    /**
     * 获取可选的清晰度级别
     *
     * 通过 `getQualityLevels` 方法获取当前播放器可选的清晰度列表，除了该 Api 外你也可以通过 `playerInfo` 获取清晰度列表，清晰度类型可见 {@link QualityLevelType}。
     * @category 清晰度
     * @returns 清晰度级别列表
     * @example
     * ```js
     * const levels = watchCore.player.getQualityLevels();
     * levels.forEach(item => {
     *   console.log('清晰度类型', item.type); // auto-自动、sd-流程
     *   console.log('清晰度级别', item.level);
     * });
     * ```
     */
    getQualityLevels(): QualityLevelItem[];
    /**
     * 切换清晰度级别
     *
     * 获取清晰度列表({@link getQualityLevels})后，通过清晰度节点的 `level` 字段设置清晰度。
     * @category 清晰度
     * @param level 清晰度级别
     * @example
     * ```js
     * const levels = watchCore.player.getQualityLevels();
     * // 切换清晰度
     * watchCore.player.changeQualityLevel(levels[1].level);
     * ```
     */
    changeQualityLevel(level: number): void;
    /**
     * 获取播放器清晰度级别
     *
     * 通过 `getCurrentQualityLevel` 方法获取当前播放器所在的清晰度级别，除了该 Api 外你也可以通过 `playerInfo` 获取清晰度级别。
     * @category 清晰度
     * @returns 清晰度级别
     * @example
     * ```js
     * const qualityLevel = watchCore.player.getCurrentQualityLevel();
     * console.log('当前清晰度级别', qualityLevel);
     * // 通过状态获取
     * const playerInfo = watchCore.player.getPlayerInfo();
     * console.log('当前清晰度级别', playerInfo.currentQualityLevel);
     * ```
     */
    getCurrentQualityLevel(): number;
    /**
     * 获取可选的倍速列表
     *
     * 通过 `getRateList` 获取当前播放器可选的倍速列表，除了该 Api 外你也可以通过 `playerInfo` 获取倍速列表。
     * @category 倍速
     * @returns 可选的倍速列表
     * @example
     * ```js
     * const rateList = watchCore.player.getRateList();
     * console.log('可选的倍速列表', rateList);
     * ```
     */
    getRateList(): number[];
    /**
     * 切换倍速
     *
     * 获取倍速列表后通过 `changeRate` 切换倍速。
     * @category 倍速
     * @param rate 倍速
     * @example
     * ```js
     * const rateList = watchCore.player.getRateList();
     * // 切换倍速
     * watchCore.player.changeRate(rateList[4]);
     * ```
     */
    changeRate(rate: number): void;
    /**
     * 获取播放器倍速
     *
     * 通过 `getCurrentRate` 获取播放器的倍速。
     * @category 倍速
     * @returns 播放器倍速
     * @example
     * ```js
     * const currentRate = watchCore.player.getCurrentRate();
     * console.log('当前倍速', currentRate);
     * ```
     */
    getCurrentRate(): number;
    /**
     * 获取回放播放时间
     *
     * 在回放下，通过 `getCurrentTime` 获取播放器的回放播放时间，除了该 Api 外你也可以通过 `playerInfo` 获取播放时间，如果当前播放的是直播流，该方法固定返回 0。
     * @category 回放
     * @returns 播放时间，单位秒
     * @example
     * ```js
     * const currentTime = watchCore.player.getCurrentTime();
     * console.log('当前回放播放时间', currentTime);
     * ```
     */
    getCurrentTime(): number;
    /**
     * 获取回放播放总时长
     *
     * 在回放下，通过 `getDurationTime` 获取播放器的回放总时长，除了该 Api 外你也可以通过 `playerInfo` 获取回放总时长，如果当前播放的是直播流，该方法固定返回 0。
     * @category 回放
     * @returns 回放总时长，单位秒
     * @example
     * ```js
     * const durationTime = watchCore.player.getDurationTime();
     * console.log('当前回放播放总时长', durationTime);
     * ```
     */
    getDurationTime(): number;
    /**
     * 设置播放进度
     *
     * 当观众拖拽回放进度条时，通过 `seekVideo` 设置回放播放进度。
     * @category 回放
     * @param time 播放时间，单位秒
     * @example
     * ```js
     * // 切到 1 分 20 秒
     * watchCore.player.seekVideo(120);
     * ```
     */
    seekVideo(time: number): void;
    /**
     * 是否支持回放视频
     *
     * @version v1.0.0
     * @category 回放
     */
    supportPlaybackVideo(): SupportResult;
    /**
     * 是否能自动切回放
     *
     * 从 v1.0.0 版本开始通过观看页 SDK 内部流程，会自行在直播结束后自动尝试切回放
     *
     * @version v0.5.1
     * @category 回放
     */
    getAutoChangePlaybackEnabled(): boolean;
    /**
     * 切换回放
     *
     * 通过 `changePlayback` 切换回放视频。从 `v2.14.0` 版本内部支持根据回放配置自动切换播放器来播放对应的视频
     *
     * @category 回放
     * @param playbackOptions 回放参数
     * @example
     * ```js
     * watchCore.player.changePlayback({
     *   // 切换参数
     * });
     * ```
     */
    changePlayback(playbackOptions: SetupPlayerPlaybackOptions): Promise<void>;
    /**
     * 获取播放器设置
     *
     * 用于获取管理后台设置的播放器信息。
     * @category 播放器设置
     * @warn fullScreenMode 需要在 {@link PlayerEvents.PlayerInited} 触发后获取才是最终值
     * @example
     * ```js
     * const setting = watchCore.player.getPlayerSetting();
     * console.log('移动端音视频切换开关', setting.mobileAudioEnabled);
     * ```
     */
    getPlayerSetting(): PlayerSetting;
    /**
     * 获取默认的播放器 logo 设置
     * @version v1.2.0
     */
    static generateDefaultPlayerLogoSetting(): PlayerLogoSetting;
    /**
     * 获取播放器 logo 设置
     *
     * 用于获取管理后台设置的播放器 logo 信息。
     *
     * 从 v1.2.0 开始可以通过 `PlvPlayerModule.generateDefaultPlayerLogoSetting()` 来获取默认配置
     *
     * @category 播放器设置
     * @example
     * ```js
     * const logoSetting = watchCore.player.getPlayerLogoSetting();
     * console.log('logo 图片', logoSetting.logoImage);
     * console.log('logo 跳转链接', logoSetting.logoHref);
     * ```
     */
    getPlayerLogoSetting(): PlayerLogoSetting;
    /**
     * 暖场设置信息
     */
    private __warmUpSetting;
    /**
     * 获取播放器暖场设置信息
     *
     * 用于获取管理后台设置的播放器暖场信息，注意暖场设置有一定延迟，需要通过 {@link PlayerEvents.PlayerWarmUpSettingChange} 事件监听信息更新。
     * @category 播放器设置
     * @example
     * ```js
     * watchCore.player.eventEmitter.on(PlayerEvents.PlayerWarmUpSettingChange, () => {
     *   const setting = watchCore.player.getPlayerWarmUpSetting();
     *   console.log('暖场类型', setting.warmUpType);
     *   console.log('暖场图片地址', setting.warmUpImg);
     *   console.log('暖场视频地址', setting.warmUpVideo);
     * });
     * ```
     */
    getPlayerWarmUpSetting(): PlayerWarmUpSetting;
    /**
     * 设置播放器暖场设置
     * @internal
     * @ignore
     * @param setting 设置信息
     */
    setPlayerWarmUpSetting(setting: PlayerWarmUpSetting): void;
    /**
     * 设置跑马灯内容
     * @internal
     * @ignore
     * @param content 内容
     */
    setMarqueeContent(content: string): void;
    /**
     * 获取点播加密播放的授权信息
     * @internal
     * @ignore
     * @param vid 点播 vid
     */
    getVodPlayToken(vid: string): Promise<VodPlayTokenData>;
    /**
     * 更新播放器回放字幕选择组件的文案和显示状态
     * @version v1.7.0
     * @category 回放
     */
    setPlayerReplaySubtitleSelectConfig(config: SubtitleSelectBtnConfig): void;
    /**
     * 设置手势 seek 方向
     * @version v2.8.0
     * @param direction 方向 vertical 垂直方向 horizontal 水平方向
     * @category 其他
     * @api
     */
    setGestureDirection(direction: GestureSeekDirection): void;
    /**
     * 销毁播放器
     *
     * 页面或组件销毁前调用 `destroyPlayer` 销毁播放器。
     * @category 销毁
     * @example
     * ```js
     * watchCore.player.destroyPlayer();
     * ```
     */
    destroyPlayer(): Promise<void>;
    /**
     * @internal
     * @ignore
     */
    destroy(): Promise<void>;
    /**
     * @internal
     * @ignore
     */
    changePlayerReplaySubtitle(): void;
    /**
     * 获取"是否开启画中画功能"
     * @category 画中画
     * @version v1.9.2
     */
    getPIPEnabled(): boolean;
    /**
     * 获取"是否开启IOS系统画中画功能"
     *
     * 注意：此功能开关并非播放器本身的功能，需要和 webview-sdk 配合使用
     * @category 画中画
     * @version v1.9.2
     */
    getPIPForIOSEnabled(): boolean;
    /**
     * 获取"PC端是否开启小窗播放功能"
     * @version v2.16.0
     * @category 画中画
     */
    getPcPIPEnabled(): boolean;
    /**
     * 当前播放器是否支持画中画
     * @version v2.16.0
     * @category 画中画
     */
    supportPictureInPicture(): boolean;
    /**
     * 获取画中画状态
     * @version v2.16.0
     * @category 画中画
     */
    getPictureInPictureStatus(): boolean;
    /**
     * 进入画中画
     * @version v2.16.0
     * @category 画中画
     */
    enterPictureInPicture(): Promise<PictureInPictureWindow | void>;
    /**
     * 退出画中画
     * @version v2.16.0
     * @category 画中画
     */
    leavePictureInPicture(): Promise<void>;
    /**
     * 切换画中画
     * @version v2.16.0
     * @category 画中画
     */
    togglePictureInPicture(): void;
    /**
     * 获取播放器统计信息
     * @internal
     * @ignore
     */
    getPlayerStatisticsInfo(): PlayerStatisticsInfoCbParams;
    /**
     * 获取播放器视频信息
     * @version v2.2.0
     * @internal
     * @ignore
     */
    getPlayerVideoInfo(): PlayerVideoInfo;
    /**
     * 刷新低延迟软解的画面，在播放器容器宽高变化时调用
     * @version v2.2.0
     * @internal
     * @ignore
     */
    resizeScreen(viewRotate?: number, bodyRotate?: number): void;
    /**
     * 设置拉流地址自定义的token
     * @version v2.4.0
     * @desc 扩展类接口，后续可以提供给客户使用，优先推荐客户传参
     * @internal
     * @ignore
     */
    setLiveStreamToken(token: string): void;
    /**
     * 执行缓冲监测切换线路/清晰度
     * @param info 准备切换的具体信息
     * @category 清晰度
     * @version v2.5.0
     */
    switchDetectionByInfo(info: PlayerDetectionSwitchDetail): void;
    /**
     * 获取直播截图地址
     * @version v2.7.0
     * @category 其他
     */
    getLiveStreamCaptureUrl(): string | undefined;
    private __generateDefaultAdvertLinkData;
    /**
     * 获取播放器广告链接数据
     * @version v2.7.0
     * @category 播放器广告
     */
    getPlayerAdvertLinkData(type: 'head' | 'stop'): LinkData | null;
    /**
     * 退出网页全屏, 仅点播播放器移动端和直播播放器移动端支持
     * @version v2.8.0
     * @category 其他
     */
    exitWebPageFullScreen(): void;
}

/**
 * 商品模块
 * @class
 * @version v2.4.0
 */
export declare class PlvProductModule extends ModuleBase {
    /**
     * 获取商品 SDK 对象
     * @internal
     * @ignore
     * @param check 检查 `window.PolyvProductSDK` 的存在
     * @throws 当 `window.PolyvProductSDK` 不存在时抛错
     * */
    getProductSdk(check?: true): PolyvProductSDKType;
    /**
     * 获取商品 SDK 对象
     * @internal
     * @ignore
     * @param check 无需检查 `window.PolyvProductSDK` 的存在
     * */
    getProductSdk(check?: false): PolyvProductSDKType | undefined;
    /**
     * 从 window 中获取商品 SDK 对象
     * @internal
     * @ignore
     */
    get PolyvProductSDK(): PolyvProductSDKType;
    /**
     * 获取商品库公共配置
     */
    getProductConfig(): ProductConfig;
    private __product;
    /**
     * 获取商品模块 SDK 单一实例
     */
    getProductTarget(): Promise<PolyvProduct>;
    private __order;
    /**
     * 获取订单模块 SDK 单一实例
     */
    getOrderTarget(): Promise<PolyvOrder>;
    private __address;
    /**
     * 获取地址模块 SDK 单一实例
     */
    getAddressTarget(): Promise<PolyvAddress>;
    private __payment;
    /**
     * 获取支付模块 SDK 单一实例
     */
    getPaymentTarget(): Promise<PolyvPayment>;
    /**
     * 是否支持商品库直接购买
     * @version v2.6.0
     */
    getDirectBuyBusinessEnabled(): boolean;
}

/**
 * 红包模块
 * @class
 */
export declare class PlvRedpackModule extends ModuleBase {
    /**
     * 生成默认的积分红包配置
     * @version v1.2.0
     */
    static generateDefaultScoreRedpackConfig(): ScoreRedpackConfig;
    /**
     * 获取积分红包配置
     *
     * 从 v1.2.0 开始可以通过 `PlvRedpackModule.generateDefaultScoreRedpackConfig()` 来获取默认配置
     *
     */
    getScoreRedpackConfig(): ScoreRedpackConfig;
    /**
     * 获取“是否可以发红包”
     * */
    private __getSendRedpackEnabled;
    /**
     * 生成默认的发红包的限制信息
     * @version v1.2.0
     */
    static generateDefaultSendRedpackConfig(): SendRedpackConfig;
    /**
     * 获取发红包的限制信息
     *
     * 从 v1.2.0 开始可以通过 `PlvRedpackModule.generateDefaultSendRedpackConfig()` 来获取默认配置
     *
     */
    getSendRedpackConfig(): SendRedpackConfig;
    /**
     * 提交红包发送
     * @api
     */
    submitSendRedpack(params: SubmitSendRedpackParams): Promise<SubmitSendRedpackResult>;
    /**
     * 获取当前用户的红包领取记录
     * @api
     */
    getRedpackReceiveRecord(params?: GetRedpackReceiveRecordParams): Promise<PageContent<RedpackReceiveRecord>>;
}

/** 数据埋点模块 */
export declare class PlvRtasModule extends ModuleBase {
    private __sender?;
    getLogonType(): string;
    /**
     * 初始化 rtas
     */
    setup(): void;
    /**
     * 上报 behavior 分类事件
     * @api
     * @param options 上报参数
     */
    trackBehaviorEvent(options: TrackEventOptions): void;
    /**
     * 上报页面 UV
     * @api
     * @param pageType 页面类型
     */
    trackPageUV(pageType: RtasTrackPageType, liveStatus?: LiveStatus): void;
    /**
     * @internal
     * @ignore
     */
    destroy(): void;
}

/**
 * 一客一码（销售邀请）模块
 * @class
 * @version v0.12.0
 */
export declare class PlvSaleInviteModule extends ModuleBase {
    /**
     * 获取传入的一客一码邀请信息
     */
    private __getSaleInviteParams;
    /**
     * 获取当前观众相关的一客一码邀请信息
     */
    private __getInviteCustomer;
    /**
     * 获取一客一码销售码（销售）
     *
     * @internal
     * @ignore
     */
    getSaleCode(): string | undefined;
    /**
     * 获取一客一码--销售邀请的客户id（当前观众）
     * @version v1.1.0
     */
    getSaleInviteCustomerId(): string | null;
    /**
     * 是否为非法的 saleCode
     * @desc 需要在需要一客一码授权时才能被正常使用
     * @example
     * ```js
     * const watchCore = getWatchCore()
     * if(watchCore.saleInvite.needSaleInviteVerify()){
     *   const isIllegal = watchCore.saleInvite.isIllegalSaleCode()
     *   console.info('当前是否为非法的', isIllegal)
     * }
     * ```
     */
    isIllegalSaleCode(): boolean;
    /**
     * 检查是否需要一客一码授权
     */
    needSaleInviteVerify(): boolean;
    /**
     * 获取一客一码短信验证是否开启
     */
    getSaleInviteVerifySmsEnabled(): boolean;
    /**
     * 获取一客一码使用场景
     * @version v1.2.0
     */
    getInviteCustomerUsageScenario(): 'wechat' | 'browser';
    /**
     * 获取是否自动授权一客一码配置
     * @version v1.1.0
     */
    checkSaleInviteAutoVerify(): boolean;
    /**
     * 获取一客一码信息采集设置信息
     * @version v1.3.0
     */
    getInviteCustomerCollectSetting(): InviteCustomerCollectSetting;
    /**
     * 验证一客一码授权
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const verifyResult = watchCore.saleInvite.verifySaleInviteAuth({ phoneNumber: '136xxxxxxxx' });
     * if (verifyResult.success) {
     *   await watchCore.setup();
     * }
     * ```
     */
    verifySaleInviteAuth(params?: VerifySaleInviteAuthParams): Promise<CommonResult<VerifySaleInviteAuthFailReason>>;
}

/**
 * SDK 加载器
 */
declare class PlvSdkLoader {
    private __watchCore;
    private __env;
    /** 获取默认的环境参数 */
    static getDefaultEnv(): SdkLoaderEnv;
    /**
     * 格式化环境参数为可用的环境参数
     */
    static formatSdkEnv(env?: unknown): SdkLoaderEnv;
    constructor(__watchCore: PolyvWatchCore, __env: SdkLoaderEnv);
    /** 获取直播播放器 */
    getLivePlayer(grayOptions: LoadSdkGrayOptions): Promise<LivePlayerLoaderResult>;
    /** 获取无延迟直播播放器 */
    getLiveLowLatencyPlayer(): Promise<LiveLowLatencyClientFn>;
    /** 获取点播播放器 */
    getVodPlayer(vrm?: boolean): Promise<PolyvVodPlayerFn>;
    /** 获取连麦 rtc 类 */
    getRtcWebSdk(): Promise<PolyvRTCWebSDKCtor>;
    /** 获取白板 SDK */
    getWhiteBoardSdk(): Promise<typeof WhiteBoardSdkTypes>;
    /** 获取 PC 端白板 SDK UI 组件 */
    getWhiteBoardNormalUI(): Promise<typeof WatchNormalUI>;
    /** 获取移动端白板 SDK UI 组件 */
    getWhiteBoardMobileUI(): Promise<typeof WatchMobileUI>;
    /** 获取 ppt-sdk 构造器 */
    getPPTH5Sdk(): Promise<PPTH5Ctor>;
    /**
     * 获取 ppt-flash 生成器
     * @warn 暂时不支持使用
     *  */
    getPPTFlashSdk(): Promise<PolyvLivePptPlayerFn>;
    /** 获取互动功能 SDK */
    getInteractionsReceiveSdk(): Promise<PolyvIRSDKType>;
    /** 获取新版互动功能 SDK */
    getIarSdk<N extends IarAppName>(appName: N, scriptUrl?: string): Promise<IarAppPkg<N>>;
    /** 获取商品 SDK */
    getProductSdk(): Promise<PolyvProductSDKType>;
    /** 获取 AI Watch SDK */
    getWatchAISdk(): Promise<PolyvWatchAISDKType>;
    /** 获取聊天室功能 SDK */
    getChatSdk(): Promise<PolyvChatSDKType>;
    /** 获取新版聊天室功能 SDK */
    getChatSdkV2(): Promise<typeof PolyvChatPkgType>;
    /** 获取新版 socket 功能 SDK */
    getSocketSdk(): Promise<typeof PolyvSocketPkgType>;
    /** 获取登录认证功能 SDK */
    getWatchIdentifySdk(): Promise<PolyvWatchIdentifySDKType>;
    /**
     * 处理互动 js 地址配置
     */
    private __getIarScriptUrl;
    /**
     * 处理除新版互动 sdk 以外的配置
     */
    private __getSdkIntegrationScriptUrl;
    private __getLoaderOptions;
    private get __domainInfo();
}

/**
 * 分享模块
 * @class
 * */
export declare class PlvShareModule extends ModuleBase {
    static generateDefaultShareSetting(): ShareSetting;
    private __shareSetting;
    /**
     * 获取分享设置
     * @version v2.5.0
     */
    getShareSetting(): ShareSetting;
    setup(): void;
    /**
     * 获取“是否支持分享”
     */
    getShareEnabled(): boolean;
    /**
     * 获取是否支持回放标题分享
     * @version v0.6.0
     */
    getPlaybackShareTitleEnabled(): boolean;
    /**
     * 获取 web 自定义分享地址
     * @version v2.5.0
     */
    getWebShareCustomUrl(): string;
    /**
     * 获取是否支持自定义分享地址追加参数
     * @version v2.5.0
     */
    getCustomShareUrlAppendParamsEnabled(): boolean;
    /**
     * 获取分享的观看页地址
     */
    getShareWatchUrl(): string;
}

export declare class PlvSmsModule extends ModuleBase {
    /**
     * 获取短信功能全局配置
     * @version v0.12.0
     * @example
     * ```js
     * const watchCore = getWatchCore()
     * const smsConfig = watchCore.sms.getSmsConfig()
     * console.log('短信图片验证码是否可用', smsConfig.smsImageCaptchaEnabled)
     * ```
     */
    getSmsConfig(): SmsConfig;
    /**
     * 生成图片验证码
     * @api
     */
    generateImageVerifyCode(): Promise<ImageVerifyCodeData>;
    /**
     * 发送短信验证码
     * @api
     */
    sendSmsVerifyCode(params: SendSmsVerifyCodeParams): Promise<SendSmsVerifyResult>;
}

/**
 * 实时字幕模块
 * @class
 * @version v0.7.0
 */
export declare class PlvSubtitleModule extends ModuleBase {
    /** 事件触发器 */
    eventEmitter: EventEmitter<SubtitleEventsRelations, SubtitleEvents>;
    /** 字幕 Socket 服务实例 */
    private __subtitleSocketService;
    /** 字幕解析服务示例 */
    private __subtitleParseLogicService;
    /** 翻译重试延迟时间 */
    private __translateRetryDelay;
    /**
     * 生成默认的字幕配置
     * @version v1.2.0
     */
    static generateDefaultSubtitleConfig(): SubtitleConfig;
    /**
     * 字幕配置
     * @version v2.0.0
     */
    private __subtitleConfig;
    /**
     * 获取字幕配置
     *
     * 从 v1.2.0 开始可以通过 `PlvSubtitleModule.generateDefaultSubtitleConfig()` 来获取默认配置
     *
     * @category 直播实时字幕
     */
    getSubtitleConfig(): SubtitleConfig;
    /**
     * 更新字幕配置
     *
     * @version v2.0.0
     * @internal
     * @ignore
     */
    updateSubtitleConfig(config: Partial<SubtitleConfig>): void;
    /** 字幕列表，按时间升序 */
    private __subtitlesList;
    /** 字幕主动延迟时间 */
    private __delayTime;
    private __tempRealCC;
    /** 回放字幕列表 */
    private __replaySubtitleList;
    /**
     * 设置当前观众是否开启实时字幕
     * @category 直播实时字幕
     * @version v0.8.0
     * */
    changeViewerSubtitleEnable(enable: boolean): void;
    /** 字幕上次时长 */
    private __relativeTime;
    /** 是否立即触发翻译 */
    private __isImmediatelyEmitTranslate;
    /**
     * 设置立即触发翻译
     * @category 直播实时字幕
     */
    changeTranslateImmediately(enable: boolean): void;
    /**
     * @internal
     * @ignore
     */
    bindSocketEvents(): void;
    /**
     * 初始化字幕列表
     * @version v1.7.0
     * @category 直播实时字幕
     */
    initSubtitleList(): Promise<void>;
    /**
     * @internal
     * @ignore
     * @warn 从 v1.7.0 版本开始，字幕模块的 setup 不会主动去初始化字幕列表，需要外部手动执行 {@link initSubtitleList}
     */
    setup(): void;
    private __onPlayerInited;
    private __listenModuleEvents;
    private __unListenModuleEvents;
    private __changeDelayTime;
    /**
     * 获取字幕历史列表数据
     * @desc 默认升序获取数据
     */
    private __getSubtitlesHistory;
    /**
     * 开启主动延迟方法
     */
    private __startDelayEmit;
    /**
     * 处理 socket-SubtitlesRealCC 实时字幕
     * @internal
     * @ignore
     */
    handlerSubtitleRealCC(data: SubtitlesRealCCMsgSocketType): void;
    /**
     * 处理 socket-SubtitlesTranslate 添加翻译到列表中
     * @internal
     * @ignore
     */
    handlerSubtitleTranslate(data: SubtitlesTranslateMsgSocketType): void;
    private __normalEmitTranslate;
    private __immediatelyEmitTranslate;
    /**
     * 触发翻译结果
     */
    private __emitSubtitleTranslate;
    /**
     * 切换字幕开关的状态
     * @internal
     * @ignore
     */
    toggleSubtitleEnable(enable: boolean, currentSubtitle?: SubtitlesEnableMsgSocketType): void;
    /**
     * 重制当前字幕列表
     * @internal
     * @ignore
     */
    resetSubtitlesList(): void;
    /**
     * 获取当前字幕列表
     * @category 直播实时字幕
     */
    getSubtitlesList(): SubtitlesListItem[];
    /**
     * 添加结果到字幕列表中
     */
    private __addSubtitlesListItem;
    /**
     * 通过索引获取历史数据
     * @desc 暂不对外使用
     * @experimental
     * @internal
     * @ignore
     */
    getHistoryListByIndex(index: number, size?: number): Promise<SubtitlesListItem[]>;
    private __unshiftSubtitleList;
    private __concatData2SubtitleList;
    /**
     * 获取回放字幕内容
     * @category 回放字幕
     * @version v0.9.0
     */
    getReplaySubtitleContent(url: string): Promise<string>;
    /**
     * 设置传入的回放字幕数据
     * @category 回放字幕
     * @version v0.9.0
     */
    setReplaySubtitleList(value: ReplaySubtitleItem[]): void;
    /**
     * 获取回放字幕的的值
     * @category 回放字幕
     * @version v0.9.0
     */
    getReplaySubtitleList(): ReplaySubtitleItem[];
    /**
     * 解析回放字幕
     * @category 回放字幕
     * @version v0.9.0
     */
    parseReplaySubtitleContent(content: string): SubtitleParsedItem[];
    /**
     * 获取回放字幕回放可选项
     * @version v1.7.0
     * @category 回放字幕
     */
    getSubtitleTranslateOptions(): Promise<SubtitleTranslateOption[]>;
    /**
     * 更新实时字幕翻译语言
     * @version v1.7.0
     * @category 直播实时字幕
     */
    updateLiveSubtitleTranslateLanguage(translateLanguage: SubtitleSourceTranslateLanguage): void;
    /**
     * 获取伪直播实时字幕开关
     * @version v2.5.0
     * @category 直播实时字幕
     */
    getRealDiskVideoRealTimeSubtitleEnabled(): boolean;
    /**
     * @internal
     * @ignore
     */
    destroy(): void;
}

/**
 * 任务奖励模块
 * @class
 * @version v1.5.0
 */
export declare class PlvTaskActivityModule extends ModuleBase {
    private __taskActivitySocketService;
    /** 任务活动播放器服务 */
    private __taskActivityPlayerService;
    /**
     * 任务活动模块事件触发器
     */
    eventEmitter: EventEmitter<TaskActivityEventsRelations, TaskActivityEvents>;
    /**
     * 当前的活动 id
     */
    private __currentActivityId?;
    /**
     * 当前活动数据
     */
    private __currentActivityData?;
    /**
     * 是否允许启动任务
     */
    private __isTaskActivityEnabled;
    /**
     * 是否已经通过detail接口初始化过
     */
    private __detailInitialized;
    /**
     * 初始化任务活动配置
     * @api
     * @example
     * ```js
     * const watchCore = getWatchCore()
     * watchCore.taskActivity.initConfig({
     *   // 注意禁止启动任务活动需要在watchCore.connect()之前调用，否则无法生效
     *   taskActivityEnabled: false,
     * })
     * ```
     */
    initConfig(options: TaskActivityInitConfigOptions): void;
    /**
     * @internal
     * @ignore
     * */
    bindChatEvents(): void;
    /**
     * @internal
     * @ignore
     * */
    bindSocketEvents(): void;
    /**
     * 发送播放器任务日志, 仅在播放器模式下有效
     * @param info 日志信息
     */
    sendPlayerTaskLog(info: string): void;
    /**
     * 设置任务活动 id
     * @internal
     * @ignore
     * @param activityId 任务活动 id
     */
    setActivityId(activityId: number): Promise<void>;
    /**
     * 移除活动 id
     * @ignore
     * @internal
     */
    removeActivityId(): void;
    /**
     * 获取活动数据
     */
    getActivityData(): TaskActivityData | undefined;
    /**
     * 刷新任务活动数据
     */
    refreshActivityData(): Promise<void>;
    /**
     * 合并任务活动数据
     */
    mergeStatusData(): Promise<void>;
    /**
     * 获取任务活动基础数据
     * @param activityId 活动 id
     */
    private __requestTaskActivityBasicData;
    /**
     * 通过 socket 获取任务状态
     * @ignore
     * @internal
     */
    private __requestTaskActivityStatusBySocket;
    /**
     * 获取任务已完成列表
     * @ignore
     * @internal
     */
    private __requestTaskActivityFinishList;
    /**
     * 合并数据
     * @param basicData 基础任务数据
     * @param statusData 状态数据
     * @param finishList 完成数据
     */
    private __mergeData;
    /**
     * 获取任务状态
     * @ignore
     * @internal
     */
    private __requestTaskActivityStatus;
    /**
     * 通过 player 获取任务状态
     * @ignore
     * @internal
     */
    private __requestTaskActivityStatusByPlayer;
    /**
     * 获取奖励列表
     */
    getTaskRewardList(options?: GetTaskRewardListOptions): Promise<PageContent<TaskRewardItem>>;
    /**
     * 获取答题任务的问卷内容
     * @param questionnaireId 问卷 id
     */
    getQuestionnaireDetail(questionnaireId: string): Promise<PolyvQuestionnaire.QuestionnaireData | undefined>;
    /**
     * 提交答题任务答案
     * @param options 提交参数
     */
    submitQuestionnaire(options: SubmitTaskQuestionnaireOptions): Promise<SubmitTaskQuestionnaireResult>;
    /**
     * 提交领奖信息
     * @version v1.9.2
     * @param id 奖励 id 或 活动id 和 任务id
     * @param receiveData 领取信息
     */
    submitRewardReceive(id: number | SubmitRewardReceiveIdOptions, receiveData: RewardAcceptFormItem[]): Promise<void>;
    /**
     * 生成任务活动默认配置
     */
    static generateDefaultTaskActivityConfig(): TaskActivityConfig;
    /**
     * 获取任务活动配置
     * @version v2.0.0
     */
    getTaskActivityConfig(): TaskActivityConfig;
    /**
     * 发送自定义事件
     * @version v2.0.0
     * @param customEvent 事件名
     */
    sendCustomEvent(customEvent: string): Promise<void>;
    /**
     * 获取在线时长任务更新类型
     * @version v2.1.0
     * @returns 在线时长任务更新类型
     */
    getOnlineTaskUpdateType(): OnlineTaskUpdateType;
    /**
     * 从频道详情接口初始化任务活动
     * @internal
     * @version v2.10.0
     */
    initializeFromChannelDetail(): Promise<void>;
    /**
     * 从指定来源设置活动ID
     * @param activityId 活动 ID
     * @param source 初始化来源
     * @version v2.10.0
     */
    setActivityIdFromSource(activityId: number, source: 'detail' | 'socket'): Promise<void>;
    /**
     * 重置detail初始化状态
     * @version v2.10.0
     */
    resetDetailInitialized(): void;
    /**
     * 销毁
     */
    destroy(): void;
    /**
     * 发送获得奖励事件
     * @ignore
     * @internal
     * @param activityId 活动 id
     * @param taskId 任务 id
     */
    sendObtainReward(activityId: number, taskId: number): Promise<void>;
}

/**
 * 时间轴标记(打点)模块
 * @class
 * @version v0.5.0
 * @internal 内部模块
 */
export declare class PlvTimeAxisMarkModule extends ModuleBase {
    /** 时间轴标记(打点)事件触发器 */
    eventEmitter: EventEmitter<TimeAxisPointEventsRelations, TimeAxisMarkEvents>;
    private __timeAxisMarkSocketService;
    bindSocketEvents(): void;
    /** 时间轴标记点(打点)列表 */
    protected _timeAxisMarkList: TimeAxisMarkInfo[];
    /**
     * 重置时间轴标记(打点)列表
     * @internal
     * @ignore
     */
    resetTimeAxisMarkList(): void;
    /**
     * 回调时间轴标记列表
     * @internal
     * @ignore
     */
    emitTimeAxisMarkList(): void;
    /**
     * 增加时间轴标记
     * @ignore
     * @internal
     * */
    addTimeAxisMark(timeAxisMark: TimeAxisMarkInfo): void;
    /**
     * 删除时间轴标记
     * @ignore
     * @internal
     * */
    deleteTimeAxisMark(timeAxisMarkId: string): void;
    /**
     * 编辑时间轴标记
     * @ignore
     * @internal
     * */
    editTimeAxisMark(timeAxisMarkId: string, markMessage: TimeAxisMarkMessage): void;
    /**
     * 判断是否启用直播打点
     */
    getLiveTimeAxisMarkEnabled(): boolean;
    /**
     * 根据播放器时间变化，更新直播打点列表数据
     * @param params
     */
    updateLiveTimeAxisMarkList(params: {
        /** 播放总时长，单位：秒 */
        duration: number;
    }): void;
    /**
     * 设置直播打点列表数据
     */
    setLiveTimeAxisMarkList(params: TimeAxisMarkQueryParam & {
        /** 播放总时长，单位：秒 */
        duration: number;
    }): Promise<void>;
    /**
     * 初始化直播打点数据
     */
    setupLiveTimeAxisMarkList(): Promise<void>;
    /**
     * 判断是否启用回放打点
     */
    getPlaybackTimeAxisMarkEnabled(): boolean;
    /**
     * 设置回放打点列表数据
     */
    setPlaybackTimeAxisMarkList(params: TimeAxisMarkQueryParam & {
        /** 播放总时长，单位：秒 */
        duration: number;
    }): Promise<void>;
    /**
     * 初始化回放打点数据
     */
    setupPlaybackTimeAxisMarkList(): Promise<void>;
    /**
     * 获取直播打点信息
     */
    getLiveTimeAxisMarkList(params: TimeAxisMarkQueryParam): Promise<GetLiveTimeAxisMarkListRequest.ResponseData>;
    /**
     * 获取回放打点信息
     */
    getPlaybackTimeAxisMarkList(params: TimeAxisMarkQueryParam): Promise<GetPlaybackTimeAxisMarkListRequest.ResponseData>;
    /**
     * @internal
     * @ignore
     */
    destroy(): void;
}

/**
 * 试看模块
 * @class
 */
export declare class PlvTrialModule extends ModuleBase {
    /**
     * 获取试看信息(需要在微信环境才能正常调用)
     * @api
     */
    getTrialInfo(): Promise<CommonResult<ChannelTrialError, ChannelTrialInfo>>;
}

/**
 * 用户(观众)模块
 * @class
 */
export declare class PlvUserModule extends ModuleBase {
    /**
     * 事件触发器
     */
    eventEmitter: EventEmitter<UserEventsRelations, UserEvents>;
    /**
     * 统计参数
     */
    private __statisticsParams;
    /**
     * 用户分组 id
     */
    private __groupId;
    /**
     * 获取用户分组 Id
     * @internal
     * @ignore
     */
    getGroupId(): string | undefined;
    /**
     * 用户(观众) Socket 服务
     */
    private __userSocketService;
    constructor(_watchCore: PolyvWatchCore);
    /**
     * 获取统计参数
     * @internal
     * @ignore
     */
    getStatisticsParams(): StatisticsParams;
    /**
     * @internal
     * @ignore
     */
    updateAppConfig(appConfig: Partial<AppConfig>): void;
    /**
     * 设置用户模块
     * @internal
     * @ignore
     */
    setup(): void;
    /**
     * 是否为测试模式观众
     * @internal
     * @ignore
     * @version v2.0.0
     */
    isTestModeUser(): boolean;
    /**
     * @internal
     * @ignore
     */
    bindSocketEvents(): void;
    /**
     * 设置观众信息
     * @internal
     * @ignore
     * @param viewerInfo 观众信息
     */
    setupViewerInfo(viewerInfo: Partial<ViewerInfo>): void;
    /**
     * 当前用户(观众)信息
     */
    private __currentUserInfo?;
    /**
     * 获取当前用户信息
     *
     * 用于获取当前用户的详细信息。
     * @param check 检查是否存在
     * @warn 未进行观看条件授权或创建 SDK 没有传入用户信息时返回 `undefined`。
     * @returns 用户信息
     * @example
     * ```js
     * const userInfo = watchCore.user.getUserInfo();
     * console.log('用户信息', userInfo);
     * ```
     */
    getUserInfo(): UserInfoDetail | undefined;
    /**
     * 获取当前用户信息
     * @ignore
     * @internal
     */
    getUserInfo(check?: true): UserInfoDetail | undefined;
    /**
     * 获取当前用户信息
     *
     * 用于获取当前用户的详细信息。
     * @param check 检查是否存在
     * @warn 未进行观看条件授权或创建 SDK 没有传入用户信息时返回 `undefined`。
     * @returns 用户信息
     * @example
     * ```js
     * const userInfo = watchCore.user.getUserInfo();
     * console.log('用户信息', userInfo);
     * ```
     * @ignore
     * @internal
     */
    getUserInfo(check?: false): UserInfoDetail;
    /**
     * 手机号脱敏处理
     * @desc 当观众昵称为手机号，且开启脱敏开关下，需要进行转换处理
     * */
    private __desensitizationForPhoneNumber;
    /**
     * 设置当前用户(观众)信息
     * @internal
     * @ignore
     * @param userInfo 新的用户信息
     */
    updateUserInfo(userInfo: Partial<UserInfoDetail>): void;
    /**
     * 判断是否为特殊的用户身份
     *
     * 用户模块提供 Api 用于判断用户身份是否为内置的特殊用户身份，如讲师、管理员、助教等。
     * @param userType 用户身份
     * @param actor 用户头衔
     * @returns 是否特殊身份
     * @example
     * ```js
     * import { ChatUserType } from '@polyv/live-watch-sdk';
     * console.log(watchCore.user.isSpecialUserType(ChatUserType.Teacher)); // true
     * console.log(watchCore.user.isSpecialUserType(ChatUserType.Manager)); // true
     * console.log(watchCore.user.isSpecialUserType(ChatUserType.Guest)); // true
     * console.log(watchCore.user.isSpecialUserType(ChatUserType.Student)); // false
     * console.log(watchCore.user.isSpecialUserType(ChatUserType.Viewer)); // false
     * console.log(watchCore.user.isSpecialUserType(ChatUserType.Dummy)); // false
     * console.log(watchCore.user.isSpecialUserType(ChatUserType.Dummy, '观众')); // false
     * ```
     */
    isSpecialUserType(userType: ChatUserType | unknown, actor?: string): boolean;
    /**
     * 获取当前用户 userId
     *
     * 用于获取当前用户的 userId，默认以时间戳字符串作为用户 userId，关于 userId 说明如下：
     * - 微信环境下进行微信授权后，以用户的微信 `openid` 作为 userId；
     * - 白名单授权后，以填写的会员码作为 userId（优先级高于微信授权）；
     *
     * @warn 未进行观看条件授权或创建 SDK 没有传入用户信息时返回 `undefined`。
     * @returns 用户 userId
     * @example
     * ```js
     * const userId = watchCore.user.getUserId();
     * console.log('用户 userId', userId);
     * ```
     */
    getUserId(): string | undefined;
    /**
     * 获取当前用户的 userId
     * @internal
     * @ignore
     * @throws 没有 userId 时抛出异常
     */
    requiredUserId(): string;
    /**
     * 获取当前用户昵称
     *
     * 用于获取当前用户的昵称。
     * @warn 未进行观看条件授权或创建 SDK 没有传入用户信息时返回 `undefined`。
     * @returns 用户昵称
     * @example
     * ```js
     * const nickname = watchCore.user.getUserNick();
     * console.log('用户昵称', nickname);
     * ```
     */
    getUserNick(): string | undefined;
    /**
     * 获取当前用户的昵称
     * @internal
     * @ignore
     * @throws nick 为 undefined 时抛出异常
     */
    requiredUserNick(): string;
    /**
     * 修改当前用户昵称
     *
     * 用于观众二次修改昵称。
     * - 通过 {@link UserEvents.CurrentUserSetNick} 事件监听修改昵称完成。
     * - 通过 {@link UserEvents.SetNickError} 事件监听设置昵称失败。
     * @param nickname 新的昵称
     * @example
     * ```js
     * watchCore.user.eventEmitter.on(UserEvents.CurrentUserSetNick, () => {
     *   toast.success('修改昵称成功');
     * });
     *
     * watchCore.user.eventEmitter.on(UserEvents.SetNickError, (data) => {
     *   toast.error('修改昵称失败：' + data.message);
     * });
     *
     * watchCore.user.updateUserNick('新的用户昵称');
     * ```
     */
    updateUserNick(nickname: string): void;
    /**
     * 将当前用户昵称记录到后端中
     * @internal
     * @ignore
     */
    recordUserNick(): Promise<void>;
    /**
     * 获取当前用户头像地址
     *
     * 用于获取当前用户的头衔地址，观看页 SDK 提供 `DEFAULT_VIEWER_AVATAR` 默认观众头像的常量。
     * @warn 未进行观看条件授权或创建 SDK 没有传入用户信息时返回 `undefined`。
     * @returns 用户头像地址
     * @example
     * ```js
     * import { DEFAULT_VIEWER_AVATAR } from '@polyv/live-watch-sdk';
     *
     * const userAvatar = watchCore.user.getUserAvatar();
     * console.log('用户头像', userAvatar);
     * console.log('默认头像', DEFAULT_VIEWER_AVATAR);
     * ```
     */
    getUserAvatar(): string | undefined;
    /**
     * 获取当前用户身份
     * @internal
     * @ignore
     */
    getUserType(): ChatUserType;
    /**
     * 获取当前用户的跑马灯名称
     * @internal
     * @ignore
     */
    getUserMarqueeName(): string;
    /**
     * 获取水印/跑马灯显示的用户名称
     * 格式：昵称_ViewID前8位
     * @internal
     * @ignore
     */
    getWatermarkNickWithViewId(): string;
    /**
     * 获取当前用户的微信 openId
     *
     * 用于获取当前用户的微信 openId，仅在微信(非)静默授权后才返回
     * @returns 微信 openId
     * @example
     * ```js
     * const openId = watchCore.user.getUserOpenId();
     * console.log('openId', openId);
     * ```
     */
    getUserOpenId(): string | undefined;
    /**
     * 获取当前用户的微信 unionId
     *
     * 用于获取当前用户的微信 unionId，仅在微信(非)静默授权后才返回
     * @returns 微信 unionId
     * @example
     * ```js
     * const unionId = watchCore.user.getUserUnionId();
     * console.log('unionId', unionId);
     * ```
     */
    getUserUnionId(): string | undefined;
    /**
     * 获取当前用户的头衔
     *
     * @version v0.11.0
     * @returns 用户头衔
     * @example
     * ```js
     * const actor = watchCore.user.getUserActor();
     * console.log('actor', actor);
     * ```
     */
    getUserActor(): string | undefined;
    /**
     * 是否需要隐藏用户头衔
     * @version v1.2.0
     */
    needHideUserActor(): boolean;
    /**
     * 获取当前用户的授权方式
     *
     * 用户获取当前用户的授权方式，未授权时返回 {@link AuthType.None}
     * @returns 授权方式
     * @example
     * ```js
     * const authType = watchCore.user.getUserAuthType();
     * console.log('当前用户的授权方式', authType);
     * ```
     */
    getUserAuthType(): AuthType;
    /**
     * 判断是否为当前用户
     * @internal
     * @ignore
     * @param userId 目标用户 id
     */
    isCurrentUser(userId: string): boolean;
    /**
     * 当前是否需要手机号实名认证
     * @version v0.8.0
     * @returns 是否需要认证
     * @example
     * ```js
     * const needAuth = watchCore.user.needRealNameAuth();
     * if (needAuth) {
     *   console.log('需要认证，显示认证弹层');
     * }
     * ```
     */
    needRealNameAuth(): Promise<boolean>;
    /**
     * 获取实名认证缓存
     */
    private __getRealNameDataStorage;
    /**
     * 保存实名认证数据
     */
    private __saveRealNameDataStorage;
    /**
     * 保存实名认证信息
     * @version v0.8.0
     * @param option 选项参数
     */
    saveRealNameData(option: SaveRealNameOptions): Promise<RealNameResult>;
    /**
     * 获取当前观众的云席信息
     * @version v0.10.0
     */
    getUserSeatInfo(): ViewerSeatInfo | undefined;
    /**
     * 获取当前观众的跟进人信息
     * @version v1.1.0
     * @desc 关联一客一码功能
     */
    getUserSaleInfo(): ViewerSaleInfo;
    /**
     * 获取邀请观看邀请员/分销员Id
     * @version v2.0.0
     */
    getInviteWatchSaleId(): string | null;
    /**
     * 获取邀请观看上级邀请员的 inviteWatchSaleId
     * @version v2.2.0
     */
    getInviteWatchInviteSalesId(): string | null;
    /**
     * @internal
     * @ignore
     */
    destroy(): void;
}

/**
 * 工具模块
 * @class
 */
export declare class PlvUtilsModule extends ModuleBase {
    /** 图片上传对象 */
    private __uploadImgCtrl;
    /**
     * 获取图片上传 SDK 实例
     * @version v0.8.0
     */
    getChatImageUploadCore(): ChatImageUpload;
    /**
     * 给图片上传 SDK 设置 channelId
     */
    private __setChannelIdForUploadImageCtrl;
    /**
     * 选择图片文件并上传多张图片
     */
    uploadMultiImage(params?: {
        /** 上传限制，默认为 9 张 */
        maxLimit?: number;
        /** 上传准备完成回调 */
        ready?: (params: UploadMultiImageReadyResult) => void;
        /** 上传完成回调，每上传完一张图片就会回调一次 */
        success?: (params: UploadMultiImageSuccessResult) => void;
        /** 上传失败回调，不影响后续图片上传 */
        fail?: (err: Error, image?: UploadMultiImageFailResult) => void;
    }): Promise<{
        /** 上传成功的图片集合 */
        successUploadImages: UploadMultiImageSuccessResult[];
        /** 上传失败的图片集合 */
        failUploadImages: UploadMultiImageFailResult[];
    }>;
    /**
     * 选择图片文件并上传单张图片
     * @api
     */
    uploadImage(): Promise<UploadImageResult>;
    /**
     * 根据文件直接上传图片
     * @api
     */
    directUploadImage(file: File | null): Promise<UploadImageResult>;
    /**
     * 生成用于重定向的二维码地址
     * @api
     * @param url 二维码内容
     */
    generateQrcodeUrl(url: string): string;
    /**
     * 翻译文本
     * @api
     * @param text 需要翻译的文本
     */
    translateText(text: string): Promise<string>;
    /**
     * 获取阿里滑块的 app key
     */
    getAliSliderAppKey(): string;
    /**
     * 生成默认资源对象
     *
     * 该方法可以一次性获取 `DEFAULT_VIEWER_AVATAR` 等默认常量
     *
     * @version v1.0.0
     * @example
     * ```js
     * import { PlvUtilsModule } from '@polyv/live-watch-sdk';
     * const defaultResource = PlvUtilsModule.generateDefaultResource();
     * console.info('默认资源外链', defaultResource);
     * ```
     */
    static generateDefaultResource(): PlvDefaultResource;
    /**
     * 获取默认资源外链
     *
     * 和直接使用 `DEFAULT_VIEWER_AVATAR` 常量不同，使用该方法可以根据传入配置的域名去获取资源外链
     * @version v1.0.0
     * @example
     * ```js
     * const watchCore = getWatchCore();
     * const defaultResource = watchCore.utils.getDefaultResource();
     * console.info('默认资源', defaultResource);
     * ```
     */
    getDefaultResource(): PlvDefaultResource;
    /**
     * 生成 PDF 预览地址
     * @version v1.1.0
     */
    generatePdfPreviewUrl<T extends object = object>(pdfUrl: string, params?: T): string;
    /**
     * 生成错误页地址
     * @version v1.1.0
     */
    generateErrorVerifyPageUrl<T extends object = object>(params?: T): string;
    /**
     * 生成个人中心页面地址
     * @version v1.11.0
     */
    generateProfilePageUrl<T extends object = object>(params?: T): string | null;
    /**
     * 生成商品讲解页面地址
     * @deprecated 新版商品库 SDK 不再需要该方法
     * @version
     */
    generateProductExplainPageUrl<T extends object = object>(params?: T): string | null;
    /**
     * 处理强制隐藏观众昵称逻辑
     * @version v2.0.0
     * @desc 当后台开启隐藏观众昵称的情况下，需要进行转换
     */
    processForceHiddenNickname(nickname: string): string;
}

export declare class PlvVerifyModule extends ModuleBase {
    /**
     * 验证观众登录令牌
     *
     * 获取观众登录令牌后，可通过 `verifyViewerLoginToken` 进行验证，验证成功后即可安装核心实例。
     * 关于获取登录令牌流程可见文档：[点击进入](https://help.polyv.net/#/live/js/new_sdk/live_watch_sdk/articles/verify-new/overview)
     * @warn 注意验证之后将会绕过观看条件授权
     * @param loginToken 观众登录令牌
     * @returns 验证结果
     * @example
     * ```js
     * import { createWatchCore } from '@polyv/live-watch-sdk';
     * // 获取登录令牌
     * function getLoginToken() {
     *   // TODO：请求 api 接口获取登录令牌
     * }
     *
     * async function example() {
     *   // 创建核心实例
     *   const watchCore = createWatchCore({ channelId: '' });
     *   // 步骤1：获取登录令牌
     *   const loginToken = await getLoginToken();
     *   // 步骤2：验证登录令牌
     *   await watchCore.verify.verifyViewerLoginToken(loginToken);
     *   // 步骤3：安装核心实例
     *   await watchCore.setup();
     *
     *   // 此时观看条件授权状态为已授权
     *   console.log(watchCore.auth.isAuthorized()); // true
     * }
     * ```
     */
    verifyViewerLoginToken(loginToken: string): Promise<VerifyLoginTokenResult>;
}

/**
 * 等待一段时间
 * @param time 等待时间
 */
export declare function plvWait(time?: number): Promise<void>;

/**
 * 等待一段时间
 * @param time 等待时间
 */
declare function plvWait_2(time?: number): Promise<void>;

/**
 * @file 水印模块
 */

export declare class PlvWatermarkModule extends ModuleBase {
    /**
     * 当前创建的水印实例对象
     */
    private __watermarkTargets;
    /**
     * 获取水印设置
     *
     * 用于获取管理后台设置的水印信息。
     * @example
     * ```js
     * const watermarkSetting = watchCore.watermark.getWatermarkSetting();
     * console.log('水印开关', watermarkSetting.watermarkEnabled);
     * console.log('水印类型', watermarkSetting.watermarkType); // 固定值 or 登录用户名
     * console.log('水印内容', watermarkSetting.watermarkContent); // 如果设置为登录用户名，则返回当前用户昵称
     * ```
     */
    getWatermarkSetting(): WatermarkSetting;
    /**
     * 是否为昵称水印
     * @internal
     * @ignore
     */
    isNicknameWatermarkType(): boolean;
    /**
     * 创建水印
     * @internal
     * @ignore
     */
    createWatermark(options: SetupWatermarkOptions): WatermarkTarget;
    /**
     * 处理设置昵称事件
     */
    private __onSetNick;
    /**
     * 监听设置昵称事件
     */
    private __listenSetNickEvents;
    /**
     * 取消事件监听
     */
    private __unlistenSetNickEvents;
    /**
     * 判断播放器水印是否启用
     * @version v2.12.0
     */
    enabledPlayerWatermark(): boolean;
    /**
     * 判断全屏水印是否启用
     * @version v2.12.0
     */
    enabledFullscreenWatermark(): boolean;
    /**
     * @internal
     * @ignore
     */
    destroy(): void;
}

/**
 * 微信和企微公共模块
 * @class
 */
declare class PlvWeixinBasicModule extends ModuleBase {
    /**
     * 获取观众微信信息
     * */
    protected _getWxInfo(): WxInfo | undefined;
}

/**
 * 微信和企微公共模块
 * @class
 */
declare class PlvWeixinBasicModule_2 extends ModuleBase_3 {
    /**
     * 获取观众微信信息
     * @description 从观众详情中获取微信相关信息
     * @returns 微信信息，如果未设置则返回undefined
     * */
    protected _getWxInfo(): WxInfo_2 | undefined;
}

/**
 * 微信模块
 * @class
 */
export declare class PlvWeixinModule extends PlvWorkWeixinModule {
    /**
     * @internal
     * @ignore
     */
    setup(): void;
    /**
     * 判断是当前用户是否为特殊授权用户
     */
    private __judgeIsSpecialAuthViewer;
    /**
     * 获取是否需要微信授权
     */
    private __getNeedWeixinAuthorized;
    /**
     * 获取是否忽略微信授权
     */
    private __getIgnoreWxAuth;
    /**
     * 获取强制微信授权开关
     */
    private __getForceWxAuthSwitch;
    /**
     * @internal
     * @ignore
     * @version v2.0.0
     */
    checkBasicForceWxAuth(): boolean;
    /**
     * 检查是否需要强制微信授权
     * @version v0.6.0
     */
    checkForceWxAuth(): boolean;
    /**
     * 检查当前环境是否需要处理微信强制授权持久化
     * @version v0.10.0
     */
    checkForceWxAuthPersistent(): boolean;
    /**
     * 获取基础的微信授权限制
     * @version v2.0.0
     */
    getBasicWeixinAuthEnabled(): boolean;
    /**
     * 获取"是否可以进行微信授权"
     * @param snsApiBase true: 使用“静默授权”进行判断 / false: 使用“非静默授权”进行判断，默认 true
     */
    getWeixinAuthEnabled(snsApiBase?: boolean): boolean;
    /**
     * 获取是否需要去做静默授权
     * @desc 需要在支持“微信授权”的情况下去使用该方法
     * @return true: 静默授权 / false: 非静默授权
     */
    getSnsApiBase(): boolean;
    /**
     * 是否已进行微信(静默)授权
     * */
    isWeixinAuthorized(): boolean;
    /**
     * 是否已进行微信非静默授权
     * */
    isWeixinWatchAuthorized(): boolean;
    /**
     * @internal
     * @ignore
     */
    getWeixinAccountFunctionEnabled(): boolean;
    /**
     * @internal
     * @ignore
     */
    getWeixinPayEnabled(): boolean;
    /**
     * 获取微信支付类型
     * */
    getWeixinPayType(): WeixinPayType;
    /**
     * 获取微信授权跳转地址
     * @internal
     * @ignore
     */
    getWeixinAuthorizeRedirectUrl(options?: GetWeixinAuthorizeRedirectUrlOptions): Promise<WeixinAuthRedirectUrlData>;
    /**
     * 跳转到微信授权地址
     */
    redirectWeixinAuthorizeUrl(options?: RedirectWeixinAuthorizeUrlOptions): Promise<void>;
    /**
     * 获取微信 js-sdk 签名
     */
    getWeixinSign(): Promise<WeixinSignData>;
    /**
     * 跳转到微信泛域名支付
     */
    redirectWatchDomainPay<T extends WatchDomainPayType>(options: RedirectWatchDomainPayOptions<T>): Promise<void>;
    /**
     * 判断是否进入微信快照页模式
     * @version v0.6.0
     */
    isWeixinSnapshotPageMode(): boolean;
    /**
     * 判断当前是否为微信快照用户
     * @version v0.6.0
     * @internal
     * @ignore
     */
    isWeixinSnapshotUser(): boolean;
    /**
     * 生成默认的微信相关配置
     * @version v1.2.0
     */
    static generateDefaultWeixinConfig(): WeixinConfig;
    /**
     * 获取微信相关配置
     *
     * 从 v1.2.0 开始可以通过 `PlvWeixinModule.generateDefaultWeixinConfig()` 来获取默认配置
     *
     * @version v0.9.0
     */
    getWeixinConfig(): WeixinConfig;
}

/**
 * 提现模块
 */
export declare class PlvWithdrawModule extends ModuleBase {
    /**
     * 获取“是否可以提现”
     */
    private __getWithdrawEnabled;
    /**
     * 生成默认的提现配置
     * @version v1.2.0
     */
    static generateDefaultWithdrawConfig(): WithdrawConfig;
    /**
     * 获取提现配置
     *
     * 从 v1.2.0 开始可以通过 `PlvWithdrawModule.generateDefaultWithdrawConfig()` 来获取默认配置
     *
     */
    getWithdrawConfig(): WithdrawConfig;
    /**
     * 申请提现
     */
    applyWithdraw(params: ApplyWithdrawParams): Promise<ApplyWithdrawResult>;
    /**
     * 取消提现
     */
    cancelWithdraw(params: CancelWithdrawParams): Promise<void>;
    /**
     * 检查提现状态
     *
     * 当观众提现确认后，通知服务端立刻获取微信的提现状态
     *
     * @version v2.0.0
     *
     */
    checkWithdrawStatus(params: CheckWithdrawStatusParams): Promise<void>;
    /**
     * 获取当前用户的提现统计数据
     */
    getUserStatistics(): Promise<UserWithdrawStatistics>;
    /**
     * 获取提现记录
     */
    getWithdrawRecord(params?: GetWithdrawRecordParams): Promise<PageContent<WithdrawRecord>>;
}

/**
 * 企业微信模块
 * @class
 * @warn 整个企微模块在 v0.11.0 以后才能正常使用，模块方法标记 `@origin` 表示之前版本提供的方法
 */
declare class PlvWorkWeixinModule extends PlvWeixinBasicModule {
    /**
     * 获取企微用户信息
     * */
    private __getWxCpUser;
    /**
     * 获取企微观看条件是否验证通过
     */
    private __getEnterpriseWatchEnabled;
    /** 企微配置 */
    private __workWeixinSetting;
    protected _setupWorkWeixinModule(): void;
    /**
     * 企微是否已过期
     * @origin
     */
    isWorkWeixinExpired(): boolean;
    /**
     * 获取企微配置
     * @version v0.11.0
     * */
    getWorkWeixinSetting(): WorkWeixinSetting;
    /**
     * 是否已进行企业微信授权
     * @origin
     * */
    isWorkWeixinAuthorized(): boolean;
    /**
     * 企微功能是否可用（旧）
     * @version v0.11.0
     * @desc 旧有逻辑，其中的 wxWorkStatusSwitch 字段，后端会认为如果没有绑定，也会返回 Y，所以可以用 {@link getWorkWeixinFunctionEnabled} 方法来判断，目前仅内部使用
     * @ignore
     * @internal
     */
    isWorkWeixinFeatureEnabled(): boolean;
    /**
     * 获取“是否可以进行企微授权”
     * @origin
     */
    getWorkWeixinAuthEnabled(): boolean;
    /**
     * 获取企业微信授权跳转地址
     * @origin
     */
    getWorkWeixinAuthorizeRedirectUrl(options?: GetWeixinAuthorizeRedirectUrlOptions): Promise<WeixinAuthRedirectUrlData>;
    /**
     * 跳转到企业微信授权地址
     * @origin
     */
    redirectWorkWeixinAuthorizeUrl(options?: RedirectWeixinAuthorizeUrlOptions): Promise<void>;
    /**
     * 获取企业微信授权二维码信息
     * @origin
     */
    getWorkWeixinAuthorizeCode(options?: GetWorkWeixinAuthorizeCodeOptions): Promise<WorkWeixinAuthorizeCodeData>;
    /**
     * 获取企业微信 js-sdk 签名
     * @origin
     */
    getWorkWeixinSign(): Promise<WeixinSignData>;
    /**
     * 获取企微观看条件是否可用
     */
    private __getEnterpriseWeChatAuthSettingEnabled;
    /**
     * 获取是否需要去做企微静默授权
     * @desc 需要在支持“企微微信授权”的情况下去使用该方法，默认静默
     * @return true: 静默授权 / false: 非静默授权
     */
    getWorkWeixinSnsApiBase(): boolean;
    /**
     * 判断是否为当前企业的成员
     * @origin
     */
    isEnterpriseStaff(): boolean;
    /**
     * 是否为企微好友
     * @version v0.11.0
     */
    isEnterpriseFriend(): boolean;
    /**
     * 获取企微好友配置
     * @version v0.11.0
     */
    getWorkWeixinFriendConfig(): WorkWeixinFriendConfig;
    /**
     * 本地 session 存储 key
     * 开启企微好友观看后，如果本地没有这个 key，需要进行企微授权，才能在添加完好友后正常进入观看页
     */
    private __wxWorkFriendFetchedKey;
    /**
     * 企微好友业务需要校验权限
     * @version v0.11.0
     */
    needValidateAuthByWorkFriend(): boolean;
    /**
     * 需要先添加为企微好友
     * @version v0.11.0
     */
    needAsWorkFriend(): boolean;
    /**
     * 限制只能通过企微观看条件观看
     * @version v0.11.0
     */
    limitByEnterpriseWatchAuth(): boolean;
    /**
     * 是否和用户体系信息冲突
     * @version v2.4.0
     */
    limitEnterpriseWatchByConflictIdentityInfo(): boolean;
    /**
     * 获取企微功能是否可用（新）
     * @version v2.6.0
     */
    getWorkWeixinFunctionEnabled(): boolean;
}

/**
 * 企业微信模块
 * @class
 * @warn 整个企微模块在 v0.11.0 以后才能正常使用，模块方法标记 `@origin` 表示之前版本提供的方法
 */
declare class PlvWorkWeixinModule_2 extends PlvWeixinBasicModule_2 {
    /**
     * 获取企微用户信息
     * */
    private __getWxCpUser;
    /**
     * 是否已进行企业微信静默授权
     * @description 检查当前用户是否已完成企业微信静默授权
     * @returns 是否已完成企业微信静默授权
     */
    hadWorkWeixinSnsBaseAuthorize(): boolean;
    /**
     * 是否已进行企业微信授权
     * @description 检查当前用户是否已完成企业微信授权（包含静默授权和非静默授权）
     * @returns 是否已完成企业微信授权
     * @origin
     */
    isWorkWeixinAuthorized(): boolean;
    /**
     * 获取企业微信授权跳转地址
     * @description 获取企业微信授权跳转的URL地址
     * @param {GetWeixinAuthorizeRedirectUrlOptions} options 授权配置
     * @returns 授权跳转数据
     * @origin
     */
    getWorkWeixinAuthorizeRedirectUrl(options?: GetWeixinAuthorizeRedirectUrlOptions_2): Promise<WeixinAuthRedirectUrlData_2>;
    /**
     * 跳转到企业微信授权地址
     * @description 执行企业微信授权跳转，跳转前会先获取授权地址
     * @param {RedirectWeixinAuthorizeUrlOptions} options 授权跳转配置
     * @returns
     * @origin
     */
    redirectWorkWeixinAuthorizeUrl(options?: RedirectWeixinAuthorizeUrlOptions_2): Promise<void>;
    /**
     * 获取企业微信授权二维码信息
     * @description 获取企业微信授权所需的二维码信息
     * @param {GetWorkWeixinAuthorizeCodeOptions} options 配置选项
     * @returns 授权二维码数据
     * @origin
     */
    getWorkWeixinAuthorizeCode(options?: GetWorkWeixinAuthorizeCodeOptions_2): Promise<WorkWeixinAuthorizeCodeData_2>;
    /**
     * 判断是否为当前企业的成员
     * @description 检查当前用户是否是当前企业的企微成员
     * @returns 是否为企业成员
     * @origin
     */
    isEnterpriseStaff(): boolean;
}

export { PolyvAddress }

declare interface PolyvAIAssistantAnswerChatMsgItem extends PolyvAIAssistantChatMsgItem<PolyvAIAssistantChatMsgSource.Answer> {
    /** 每次回传的部分新消息内容, */
    newMsgPartContent: string;
}

/** AI 助手答疑消息项 */
declare interface PolyvAIAssistantChatMsgItem<S extends PolyvAIAssistantChatMsgSource> {
    /** 消息 Id */
    id?: string;
    /** 消息组，大部分情况下，一组消息中包含一问一答 */
    group: string;
    /** 消息源 */
    msgSource: S;
    /** 完整消息内容 */
    content: string;
    /** 用户 */
    user: PolyvAIAssistantChatMsgUser;
}

/** AI 助手答疑消息源 */
declare enum PolyvAIAssistantChatMsgSource {
    /** 提问 */
    Question = "question",
    /** 回答 */
    Answer = "answer"
}

/** AI 助手答疑消息类型 */
declare type PolyvAIAssistantChatMsgType = PolyvAIAssistantChatMsgTypeMap[keyof PolyvAIAssistantChatMsgTypeMap];

declare type PolyvAIAssistantChatMsgTypeMap = {
    [PolyvAIAssistantChatMsgSource.Question]: PolyvAIAssistantChatMsgItem<PolyvAIAssistantChatMsgSource.Question>;
    [PolyvAIAssistantChatMsgSource.Answer]: PolyvAIAssistantAnswerChatMsgItem;
};

/** AI 助手答疑消息用户 */
declare interface PolyvAIAssistantChatMsgUser {
    /** 用户 id */
    userId: string;
    /** 头像 */
    pic?: string;
    /** 昵称 */
    nick: string;
}

/** AI 助手聊天状态 */
declare enum PolyvAIAssistantChatStatus {
    /** 等待用户输入 */
    Wait = "Wait",
    /** 回答中 */
    Replaying = "Replaying",
    /** 繁忙 */
    Busy = "Busy"
}

/** AI 助手配置 */
export declare interface PolyvAIAssistantConfig extends PolyvAIDigitalConfig {
    /** AI 助手开关，默认关 */
    aiAssistantEnabled: boolean;
    /** AI 助手是否过期，默认为 false */
    aiAssistantExpired: boolean;
}

/** AI 助手信息 */
export declare interface PolyvAIAssistantInfo extends PolyvAIDigitalInfo {
    /** AI 助手Id，默认 -1 */
    aiAssistantId: number;
    /** AI 助手名称，默认为 'AI' */
    aiAssistantName: string;
    /**
     * AI 助手编码
     * @warn 注意，如果需要完整的 AI 助手功能，需要确保 aiAssistantCode 存在，不然只能使用基础的聊天功能
     */
    aiAssistantCode?: string;
    /** AI 助手 Token */
    aiAssistantToken?: string;
    /** AI 助手欢迎语 */
    welcomeSpeech: string;
}

declare interface PolyvAIDigitalConfig {
    /** AI 数字人开关 */
    aiDigitalHumanEnabled: boolean;
}

declare interface PolyvAIDigitalInfo {
    /** AI 数字人 Id,，默认 -1*/
    digitalHumanId: number;
    /** AI 数字人名称 */
    digitalHumanName: string;
    /** 视频资源 */
    videoSource: {
        speakUrl: string;
        noSpeakUrl: string;
    };
}

/**
 * 保利威 AI 模块
 * @class
 * @version v0.10.0
 * @warning 从 v2.8.0 开始直接重构，以 live-watch-ai-sdk 为准
 */
export declare class PolyvAIModule extends ModuleBase {
    private __watchAICore;
    /**
     * 获取 AI 核心实例
     * @version v2.7.0
     * @desc 从 v2.8.0 开始改成同步，并且可能返回 undefined
     */
    getWatchAICore(): PolyvWatchAICore | undefined;
    private __initWatchAICore;
    /**
     * 由外部初始化 AI 核心
     * @version v2.8.0
     * @desc 需要在 watchCore.setup 之后调用
     */
    setupWatchAICore(): Promise<void>;
    /**
     * @ignore
     * @internal
     */
    setup(): void;
    /**
     * @ignore
     * @internal
     */
    updateAppConfig(appConfig: Partial<AppConfig>): void;
    /**
     * 是否支持 AI 助手聊天功能
     */
    supportAIAssistantChat(): SupportResult;
    /**
     * 生成默认的 AI 助手相关配置
     * @version v1.2.0
     */
    static generateDefaultAIAssistantConfig(): PolyvAIAssistantConfig;
    /** AI 助手相关配置 */
    private __AIAssistantConfig;
    /**
     * 获取 AI 助手相关配置
     */
    getAIAssistantConfig(): PolyvAIAssistantConfig;
    /**
     * 生成默认的 AI 助手相关配置
     */
    static generateDefaultAIAssistantInfo(): PolyvAIAssistantInfo;
    /** AI 助手相关配置 */
    private __aiAssistantInfo;
    getAIAssistantInfo(): PolyvAIAssistantInfo;
    /**
     * 获取频道关联的 AI 助手信息
     * @version v2.8.0
     */
    getChannelRelatedAIAssistantInfo(): PolyvAIAssistantInfo;
    /**
     * @internal
     * @ignore
     */
    destroy(): void;
}

declare namespace PolyvAnswerCard {
    export {
        AnswerCard,
        AnswerCardData,
        AnswerCardResult,
        AnswerCardSubmitResult,
        AnswerCardType
    }
}
export { PolyvAnswerCard }

declare class PolyvApi extends ApiQuery_2<PolyvApiOptions> {
    constructor(options: PolyvApiConfig);
    private __polyvBeforeRequest;
    private __polyvAfterResponse;
}

declare type PolyvApiConfig = ApiQueryConfig_2;

declare interface PolyvApiOptions extends ApiOptions_2 {
    /** 成功状态码，默认：200 */
    successCode?: number;
    /** 是否标准的接口，默认：true */
    isStandard?: boolean;
    /** 是否不带上 channelId，默认：false */
    ignoreChannelId?: boolean;
    /** 是否不带上 viewerToken ，默认：false */
    ignoreViewerToken?: boolean;
    /** 是否需要自动带上 viewerId，默认：false */
    needViewerId?: boolean;
}

declare class PolyvApiRequest extends PolyvRequest<PolyvApiRequestOptions> {
    constructor(interactionCore: InteractionCore);
}

declare class PolyvApiRequest_2 extends PolyvRequest<PolyvApiRequestOptions_2> {
    constructor(aiCore: PolyvWatchAICore);
}

declare interface PolyvApiRequestOptions extends RequestOptions {
}

declare interface PolyvApiRequestOptions_2 extends RequestOptions {
}

export { PolyvBulletin }

declare interface PolyvChatSDKType {
    Chat: typeof Chat;
    Ask: typeof Ask;
    PlvSocket: typeof PlvSocket;
}

declare namespace PolyvCheckIn {
    export {
        CheckIn,
        CheckInData,
        CheckInEvent,
        CheckInEventRelations,
        CheckInFailReason,
        CheckInRecordData
    }
}
export { PolyvCheckIn }

declare namespace PolyvCoupon {
    export {
        Coupon,
        CouponBaseData,
        CouponCommonData,
        CouponCommonListData,
        CouponConfig,
        CouponEvent,
        CouponEventRelations,
        CouponRule,
        CouponRuleCondition,
        CouponRuleUnit,
        CouponStatus,
        CouponSwitchContent,
        CouponUserData,
        CouponUserListData,
        CouponUseTimeType
    }
}
export { PolyvCoupon }

declare namespace PolyvInteractionCore {
    export {
        AESDecryptRequestOptions,
        AESRequestOptions,
        AppSignSecretKey,
        AuthorizeAppSignRequestOptions,
        AuthorizeTokenRequestOptions,
        ChannelConfig_2 as ChannelConfig,
        ChannelInfo,
        ChannelProductHotEffectTips,
        ChannelProductPushingStatusInfo,
        ChannelTokenData,
        CheckSensitiveWordsFailReason,
        CommonResult_2 as CommonResult,
        DomainInfo_2 as DomainInfo,
        ExtBusinessInfo_2 as ExtBusinessInfo,
        ImageCutOptions,
        InteractionCore,
        InteractionCoreConfig,
        MaybePromise_2 as MaybePromise,
        MaybeSocket,
        PageContent_2 as PageContent,
        PageOptions,
        PolyvBusinessRequestPluginOptions,
        RequestAuthorizeMethod,
        ResultFail_2 as ResultFail,
        ResultSuccess_2 as ResultSuccess,
        ResultSuccessBasic_2 as ResultSuccessBasic,
        RtasConfig,
        SecurityMode,
        SignatureMethod,
        SM2Key,
        SM2RequestOptions,
        SourceInfo,
        SourceType,
        StatusCodeRequestOptions,
        TrackEventData,
        UploadImageOptions,
        UserInfo_2 as UserInfo,
        ViewerTokenData,
        YN_3 as YN
    }
}
export { PolyvInteractionCore }

/**
 * 互动功能 SDK 导出类型
 */
export declare interface PolyvIRSDKType {
    updateConfig: typeof updateConfig;
    updateRatsConfig: typeof updateRatsConfig;
    Announcement: typeof IarAnnouncement;
    AnswerCard: typeof IarAnswerCard;
    CheckIn: typeof IarCheckIn;
    EnrollLottery: typeof IarEnrollLottery;
    FeedBack: typeof IarFeedBack;
    Lottery: typeof IarLottery;
    Product: typeof IarProduct;
    PushCard: typeof IarPushCard;
    QuestionAnswer: typeof IarQuestionAnswer;
    Questionnaire: typeof IarQuestionnaire;
    RedEnvelope: typeof IarRedpack;
    RedpackRain: typeof IarRedpackRain;
    SeatTable: typeof IarSeatTable;
    Tuwen: typeof IarTuwen;
    Vote: typeof IarVote;
    WelfareLottery: typeof IarWelfareLottery;
    Topic: typeof IarTopicPK;
    RushAnswer: typeof IarRushAnswer;
    AddressManagement: typeof IarAddressManagement;
    Order: typeof IarOrder;
}

declare interface PolyvLivePlayerFn {
    (options: LivePlayerOptions): LivePlayerInstance;
    liveVersion?: string;
}

declare type PolyvLivePptPlayerFn = typeof polyvLivePptPlayerFn;

/**
 * @file 加载 ppt-sdk js
 */

declare function polyvLivePptPlayerFn(config: PPTH5Config): PPTH5Instance;

declare namespace PolyvLottery {
    export {
        AnswerCondition,
        AnswerQuestionItem,
        AnswerQuestionItemBasic,
        AnswerQuestionItemOption,
        AnswerQuestionItemType,
        AnswerQuestionType,
        AnswerResultData,
        CommentCondition,
        DurationCondition,
        GetLotteryViewerSizeOptions,
        GetLotteryWinnersOptions,
        GetViewerLabelListOptions,
        InviteCondition,
        Lottery,
        LotteryActivityData,
        LotteryActivityDurationType,
        LotteryBasicData,
        LotteryBasicOptions,
        LotteryCondition,
        LotteryConditionBase,
        LotteryConditionData,
        LotteryCustomGroupItem,
        LotteryCustomGroupType,
        LotteryDetail,
        LotteryEvent,
        LotteryEventRelations,
        LotteryFailReason,
        LotteryInviteType,
        LotteryLaunchCustomGroupItem,
        LotteryLaunchFailReason,
        LotteryLaunchForm,
        LotteryLaunchFormBase,
        LotteryLaunchFormCondition,
        LotteryLaunchFormQuestionnaireInfo,
        LotteryLaunchFormRange,
        LotteryLaunchFormTime,
        LotteryLaunchPresetInfo,
        LotteryLaunchPrizeForm,
        LotteryLaunchPrizeFormInfoItem,
        LotteryLaunchRecordData,
        LotteryLaunchRecordPrizeData,
        LotteryMode,
        LotteryPrizeDetail,
        LotteryPrizeInfo,
        LotteryRange,
        LotteryReceiveData,
        LotteryReceiveFormItem,
        LotteryReceiveFormType,
        LotteryRecordData,
        LotteryResult,
        LotteryStatus,
        LotteryWinnersData,
        LotteryWinnersGroup,
        NoneCondition,
        PrizeAcceptType,
        QuestionnaireCondition,
        SearchUserListOptions,
        StartLotteryAnswerResult,
        SubmitAnswerParams,
        SubmitAnswerResult_2 as SubmitAnswerResult,
        SubmitReceiveOptions,
        ViewerLabelItem
    }
}
export { PolyvLottery }

export { PolyvLuckyBag }

declare namespace PolyvLuckyLottery {
    export {
        Channel,
        CollectItem,
        CollectItemType,
        LuckyLottery,
        LuckyLotteryActivityDetailData,
        LuckyLotteryActivityItem,
        LuckyLotteryEvent,
        LuckyLotteryEventRelations,
        LuckyLotteryMissSetting,
        LuckyLotteryPrize,
        LuckyLotteryPrizeItem,
        LuckyLotteryReceiveData,
        LuckyLotteryReceiveFormItem,
        LuckyLotteryReceiveItem,
        LuckyLotteryResult,
        LuckyLotteryResultPrizeItem,
        LuckyLotterySocketEvent,
        LuckyLotterySubmitReceiveItem,
        LuckyLotterySubmitReceiveOptions,
        LuckyLotteryTemplate,
        LuckyLotteryWinnersItem,
        PrizeAcceptType_2 as PrizeAcceptType,
        PrizeType,
        RewardReceiveFormType
    }
}
export { PolyvLuckyLottery }

declare interface PolyvObjectFn {
    (select: string | HTMLElement): {
        livePlayer: PolyvLivePlayerFn;
    };
    liveVersion?: string;
}

export { PolyvOrder }

export { PolyvPayment }

export { PolyvProduct }

export declare interface PolyvProductSDKType {
    Product: typeof PolyvProduct;
    Order: typeof PolyvOrder;
    Address: typeof PolyvAddress;
    Payment: typeof PolyvPayment;
}

declare namespace PolyvQuestionnaire {
    export {
        formatQuestionAnswer,
        getQuestionDefaultAnswer,
        getRequestAnswer,
        lettersToNumber,
        numberToLetters,
        FillPartData,
        FillQuestionData,
        OptionStatistics,
        QuestionAnswerType,
        QuestionItem,
        QuestionItemType,
        Questionnaire,
        QuestionnaireBasicData,
        QuestionnaireData,
        QuestionnaireEvent,
        QuestionnaireEventRelations,
        QuestionnaireRankData,
        QuestionnaireStatistics,
        QuestionnaireType,
        QuestionOption,
        QuestionStatistics,
        SubmitAnswerData,
        SubmitAnswerResult,
        ViewerAnswerResult,
        ViewerAnswerResultData
    }
}
export { PolyvQuestionnaire }

declare interface PolyvRTCWebSDKCtor {
    new (options: RtcWebSdkOptions): RtcWebSdkInstance;
    /** 当前环境是否支持连麦 */
    support: boolean;
    /** 当前环境是否支持屏幕共享 */
    isScreenShareSupported(): boolean;
    /** 当前环境是否支持画中画模式 */
    isPipSupported(): boolean;
    /** 当前页面是否存在画中画 */
    isPiping(): boolean;
    /** 获取channel类 */
    getChannelJson({ uid, channelId, param2, apiHostLive, }: {
        uid: string;
        channelId: string;
        param2: string;
        apiHostLive?: string;
    }): RtcChannelJsonInstance;
}

/**
 * 创建点播播放器方法类型
 */
declare interface PolyvVodPlayerFn {
    readonly version: string;
    (options: VodPlayerOptions): VodPlayerInstance;
}

export { PolyvVote }

declare class PolyvWatchAICore {
    /** 域名处理模块 */
    domain: PlvDomainModule_2;
    /** AI 智能大纲模块 */
    aiSummary: PlvAISummaryModule;
    /** AI 助手模块 */
    aiAssistant: PlvAIAssistantModule;
    /**
     * 直播 api 请求器
     * @internal
     * @ignore
     */
    polyvApi: PolyvApiRequest_2;
    /**
     * 基础请求器（无baseUrl）
     * @internal
     * @ignore
     */
    basicApi: BasicApiRequest;
    /**
     * 配置参数
     */
    private __appConfig;
    /**
     * 获取应用配置
     *
     * @description 获取当前应用的所有配置参数，包括域名、频道信息、用户信息回调等
     * @returns 应用配置对象
     */
    getAppConfig(): OmitAppConfig_2;
    /**
     * 更新应用配置
     *
     * @description 更新当前应用的配置参数，会合并到现有配置中，同时更新域名模块的配置
     * @param appConfig - 部分配置对象，只更新传入的字段
     */
    updateAppConfig(appConfig: Partial<OmitAppConfig_2>): void;
    /**
     * 构造函数
     *
     * @description 创建 PolyvWatchAICore 实例，初始化各个模块和 API 请求器
     * @param config - 初始配置参数，包含应用配置和各个回调函数
     */
    constructor(config: AICoreConfig);
    /**
     * 初始化设置
     *
     * @description 初始化所有模块，包括域名模块、AI 智能大纲模块和 AI 助手模块
     */
    setup(): void;
    /**
     * 获取观众 Token
     *
     * @description 获取当前观众的访问令牌，用于身份验证和权限控制
     * @returns 观众 Token 数据对象，包含 viewerToken 字段
     *
     * @example
     * ```typescript
     * const aiCore = new PolyvWatchAICore({ getViewerToken: () => ({ viewerToken: 'xxx' }) });
     * const viewerToken = await aiCore.getViewerToken();
     * console.log('观众Token:', viewerToken.viewerToken);
     * ```
     */
    getViewerToken(): Promise<ViewerTokenData_2>;
    /**
     * 获取聊天室 Token
     *
     * @description 获取聊天室的访问令牌，用于进入直播间聊天室
     * @returns 聊天室 Token 数据对象，包含 chatToken 字段
     *
     * @example
     * ```typescript
     * const aiCore = new PolyvWatchAICore({ getChatToken: () => ({ chatToken: 'xxx' }) });
     * const chatToken = await aiCore.getChatToken();
     * console.log('聊天室Token:', chatToken.chatToken);
     * ```
     */
    getChatToken(): Promise<ChatTokenData>;
    /**
     * 获取频道配置
     *
     * @description 获取当前直播间的配置信息，包括 AI 功能开关、聊天设置等
     * @returns 频道配置数据，如果未提供获取函数则返回 null
     */
    getChannelConfig(): Promise<ChannelConfig_3 | null>;
    /**
     * 获取频道信息
     *
     * @description 获取当前直播间的基本信息，包括频道 ID、频道名称等
     * @returns 频道信息数据，如果未提供获取函数则返回 null
     */
    getChannelInfo(): Promise<ChannelInfo_2 | null>;
    /**
     * 获取频道 ID
     *
     * @description 从频道信息中提取并返回频道 ID
     * @returns 频道 ID 字符串，如果无法获取则返回空字符串
     *
     * @example
     * ```typescript
     * const aiCore = new PolyvWatchAICore({
     *   getChannelInfo: () => ({ channelId: '123456', channelName: '直播测试' })
     * });
     * const channelId = await aiCore.getChannelId();
     * console.log('频道ID:', channelId); // '123456'
     * ```
     */
    getChannelId(): Promise<string>;
    /**
     * 获取聊天室 ID
     *
     * @description 获取直播间的聊天室 ID，目前实现中复用频道 ID
     * @returns 聊天室 ID 字符串
     */
    getChatRoomId(): Promise<string>;
    /**
     * 获取用户信息
     *
     * @description 获取当前用户的信息，包括用户 ID、昵称、头像等。如果未提供获取函数，则生成一个默认的临时用户信息
     * @returns 用户信息对象，包含 userId、nick、pic 字段
     *
     * @example
     * ```typescript
     * const aiCore = new PolyvWatchAICore({
     *   getUserInfo: () => ({ userId: 'user_123', nick: '张三', pic: 'https://xxx/avatar.png' })
     * });
     * const userInfo = await aiCore.getUserInfo();
     * console.log('用户ID:', userInfo.userId);
     * console.log('昵称:', userInfo.nick);
     * console.log('头像:', userInfo.pic);
     * ```
     */
    getUserInfo(): Promise<UserInfo_3>;
    /**
     * 销毁实例
     *
     * @description 销毁 PolyvWatchAICore 实例，释放所有资源，包括关闭 API 请求器和各个模块
     */
    destroy(): void;
}

declare namespace PolyvWatchAISDK {
    export {
        plvInterval_2 as plvInterval,
        plvParseJson_2 as plvParseJson,
        plvWait_2 as plvWait,
        setDebugMode_2 as setDebugMode,
        AiAssistantAudioTaskResultStatus,
        AIAssistantEvents,
        AIAssistantEventsRelations,
        AICoreConfig,
        AISubtitleParsedItem,
        ChannelConfig_3 as ChannelConfig,
        ChannelInfo_2 as ChannelInfo,
        ChatTokenData,
        LangType,
        OmitAppConfig_2 as OmitAppConfig,
        PlaybackOutlineContentItem,
        PlaybackOutlineData,
        PlaybackOutlineOptions,
        PlaybackQuestionData,
        PlaybackQuestionItem,
        PlaybackQuestionOption,
        PlvAIAssistantModule,
        PlvAISummaryModule,
        PlvDomainModule_2 as PlvDomainModule,
        PolyvAIAssistantAnswerChatMsgItem,
        PolyvAIAssistantChatMsgItem,
        PolyvAIAssistantChatMsgSource,
        PolyvAIAssistantChatMsgType,
        PolyvAIAssistantChatMsgTypeMap,
        PolyvAIAssistantChatMsgUser,
        PolyvAIAssistantChatStatus,
        PolyvAIAssistantConfig,
        PolyvAIAssistantInfo,
        PolyvAIDigitalConfig,
        PolyvAIDigitalInfo,
        PolyvWatchAICore,
        SendAIQuestionMsgOptions,
        UserInfo_3 as UserInfo,
        ViewerTokenData_2 as ViewerTokenData
    }
}

/**
 * @file 加载 Watch AI SDK js
 */

declare type PolyvWatchAISDKType = typeof PolyvWatchAISDK;

declare class PolyvWatchApi extends ApiQuery<PolyvWatchApiOptions> {
    /** 鉴权令牌 */
    __xAuthToken?: string;
    setXAuthToken(xAuthToken: string): void;
    getXAuthToken(): string | undefined;
    /** 鉴权令牌相关配置 */
    private __xAuthTokenConfig;
    setXAuthTokeConfig(params: Partial<PolyvWatchApiTokenConfig>): void;
    constructor(options: PolyvWatchApiConfig);
    private __polyvWatchInterceptRequestUrl;
    private __polyvWatchBeforeRequest;
    /** 补充请求参数 */
    private __polyfillPolyvWatchRequestParams;
    /** 响应处理器 */
    private __polyvWatchAfterResponse;
    private __handleResponseHeader;
}

declare class PolyvWatchApi_2 extends ApiQuery_2<PolyvWatchApiOptions_2> {
    /** 鉴权令牌 */
    __xAuthToken?: string;
    private get __xAuthTokenStorageKey();
    setXAuthToken(xAuthToken: string): void;
    getXAuthToken(): string | undefined;
    /** 鉴权令牌相关配置 */
    private __xAuthTokenConfig;
    setXAuthTokeConfig(params: Partial<PolyvWatchApiTokenConfig_2>): void;
    constructor(options: PolyvWatchApiConfig_2);
    private __polyvWatchInterceptRequestUrl;
    private __polyvWatchBeforeRequest;
    /** 补充请求参数 */
    private __polyfillPolyvWatchRequestParams;
    /** 响应处理器 */
    private __polyvWatchAfterResponse;
    private __handleResponseHeader;
    private __maxRetryCount;
    private __currentRetryCount;
    /**
     * 重试错误就说明授权过期
     */
    retry2RefreshApiToken(): Promise<{
        success: true;
    } | {
        success: false;
        error: Error | ApiError;
    }>;
}

declare type PolyvWatchApiConfig = ApiQueryConfig;

declare type PolyvWatchApiConfig_2 = ApiQueryConfig_2;

declare interface PolyvWatchApiOptions extends ApiOptions {
    /** 是否为静态请求 */
    isStaticRequest?: boolean;
    /** 不需要缓存 */
    noCache?: true;
    /** 不携带 token */
    withoutToken?: true;
    /** 对 params 进行签名 */
    signParams?: true;
    /** 成功状态码，默认：200 */
    successCode?: number;
    /** 不携带 source 信息 */
    withoutSourceInfo?: boolean;
}

declare interface PolyvWatchApiOptions_2 extends ApiOptions_2 {
    /** 是否为静态请求 */
    isStaticRequest?: boolean;
    /** 不需要缓存 */
    noCache?: true;
    /** 不携带 token */
    withoutToken?: true;
    /** 对 params 进行签名 */
    signParams?: true;
    /** 成功状态码，默认：200 */
    successCode?: number;
    /** 携带 clientId，默认不携带 */
    withClientId?: true;
}

declare interface PolyvWatchApiTokenConfig {
    requestMode: PolyvWatchApiTokenRequestMode;
}

declare interface PolyvWatchApiTokenConfig_2 {
    /**
     * 请求模式
     * @desc 从 v1.1.0 开始，默认从 header 改成 url
     * */
    requestMode: PolyvWatchApiTokenRequestMode_2;
}

declare type PolyvWatchApiTokenRequestMode = 'header' | 'url';

declare type PolyvWatchApiTokenRequestMode_2 = 'header' | 'url';

/** 保利威观看页-核心模块 */
export declare type PolyvWatchCore = InstanceType<typeof WatchCore>;

/**
 * 观看核心事件
 * @eventenum {@link PolyvWatchCoreEventsRelations}
 */
export declare enum PolyvWatchCoreEvents {
    /**
     * 核心安装完成钩子
     * @description 调用 `watchCore.setup` 安装成功后触发该钩子。
     * @example
     * ```js
     * import { createWatchCore, PolyvWatchCoreEvents } from '@polyv/live-watch-sdk';
     * const watchCore = createWatchCore({
     *   channelId: '频道号'
     * });
     * watchCore.setup();
     *
     * watchCore.eventEmitter.on(PolyvWatchCoreEvents.WatchCoreSetuped, () => {
     *   console.log('安装成功');
     * });
     * ```
     */
    WatchCoreSetuped = "WatchCoreSetuped",
    /**
     * 聊天室连接完成钩子
     * @description 调用 `watchCore.connect` 连接聊天室完成后触发该钩子，触发后即可显示直播观看页。
     * @example
     * ```js
     * watchCore.connect();
     *
     * watchCore.eventEmitter.on(PolyvWatchCoreEvents.WatchCoreConnected, () => {
     *   console.log('连接成功');
     * });
     * ```
     */
    WatchCoreConnected = "WatchCoreConnected",
    /**
     * 聊天室断联完成钩子
     * @description 调用 `watchCore.disconnect` 断联聊天室完成后触发该钩子，只有断联后，才能重新去调用 `watchCore.connect`方法
     * @example
     * ```js
     * watchCore.disconnect();
     *
     * watchCore.eventEmitter.on(PolyvWatchCoreEvents.WatchCoreDisconnected, () => {
     *   console.log('断联成功');
     * });
     * ```
     */
    WatchCoreDisconnected = "WatchCoreDisconnected",
    /**
     * 观看核心已销毁
     * @internal
     * @ignore
     * @description 事件触发后，表示核心实例已销毁，所有模块不能使用，需要重新创建 watchCore
     */
    WatchCoreDestroyed = "WatchCoreDestroyed"
}

export declare type PolyvWatchCoreEventsRelations = {};

/**
 * @file 加载登录认证功能 SDK js
 */

declare interface PolyvWatchIdentifySDKType {
    createWatchIdentifyCore: typeof createWatchIdentifyCore;
    IdentifyCore: typeof IdentifyCore;
}

/**
 * 竖屏播放器画面适配类型
 */
export declare enum PortraitPlayerScreenType {
    /**
     * 默认
     */
    Default = "default",
    /**
     * 完整画面
     */
    Full = "full",
    /**
     * 填充画面
     */
    Fill = "fill"
}

/** PostAiAssistantGetAudioTaskResultRequest 响应数据 */
declare interface PostAiAssistantGetAudioTaskResultResponseData {
    /** 音频链接 */
    audioUrl: string;
    /** 语音任务状态 */
    status: AiAssistantAudioTaskResultStatus;
}

/**
 * ppt-sdk 实例化参数类型
 */
declare interface PPTH5Config {
    /** 选择器 */
    content: string | HTMLElement;
    /** 宽度，默认：100% */
    width?: string;
    /** 高度，默认：100% */
    height?: string;
    hasPaintbrush?: boolean;
    canEditPaint?: boolean;
    lang?: string;
    /** 聊天室 api 域名 */
    domainName?: string;
    /** api.polyv.net 域名 */
    apiDomainName?: string;
    needSessionId?: boolean;
    toClearPaintWhenStart?: boolean;
    pptCheckDrawMarkEnabled?: boolean;
    requestGetWatchStatus?: boolean;
    showChangePPTSiteBtn?: boolean;
    showToolWhenMini?: boolean;
    swichPaintStatusTimeout?: boolean;
    fixedWhiteProp?: number;
    directionKeyEnabled?: boolean;
    settingNavBottom?: string;
    showFullPPTBtn?: boolean;
    avifEnabled?: boolean;
    viewerPrintEnabled?: boolean;
    switchPageEnabled?: boolean;
    hasScrollForPPT?: boolean;
    useVisionControl?: boolean;
}

/**
 * ppt-sdk 构造器
 */
declare interface PPTH5Ctor {
    new (config: PPTH5Config): PPTH5Instance;
}

/**
 * ppt-sdk 实例类型
 */
declare interface PPTH5Instance {
    updateSwitchPageEnabled(enabled: boolean): void;
    setDirectionKeyEnabled(enabled: boolean): void;
    /** 插入 socket 数据 */
    drawMsgFromSocket(socketData: any, delayTime?: number): void;
    /** 设置用户信息 */
    initPPTData(data: any): void;
    /** 设置水印 */
    setWatermark(config: any): void;
    /** 重制尺寸 */
    resize(): void;
    /** 重载 iframe */
    iframeReload(): void;
    /** 触发操作 */
    clickCtrlPrevBtnEvent(type: string): void;
    /** 开启回放 */
    VODStart(options: any, callback: any): void;
    /** 播放回放 */
    VODPlay(callback: any): void;
    on(event: string, handle: AnyFunc): void;
    off(event: string, handle: AnyFunc): void;
    giveViewerAuth(): void;
    removeViewerAuth(): void;
    toDeleteAll(): void;
    switchLang(lang: string): void;
    /** 销毁 */
    destroy(): void;
}

/**
 * 本地预览设置
 * @param videoEl 视频预览容器（开启视频时必填）
 * @param video 是否预览视频，默认 true
 * @param audio 是否采集音频（不会做音量推送），默认 false
 * @param fit 视频显示模式，默认 'cover'
 */
declare interface PreviewConfig {
    videoEl?: HTMLElement;
    video?: boolean;
    audio?: boolean;
    fit?: 'cover' | 'contain';
    facingMode?: FacingMode;
}

declare interface PreviewHandle {
    stream: MediaStream;
    videoTrack?: MediaStreamTrack;
    audioTrack?: MediaStreamTrack;
}

/**
 * 中奖采集方式
 */
declare enum PrizeAcceptType {
    /**
     * 无领取
     */
    None = "none",
    /**
     * 表单
     */
    Form = "form",
    /**
     * 外链
     */
    Link = "link",
    /**
     * 识别二维码
     */
    QrCode = "qrCode"
}

/**
 * 中奖采集方式
 */
declare enum PrizeAcceptType_2 {
    /**
     * 表单
     */
    Form = "form",
    /**
     * 识别二维码
     */
    QrCode = "qrCode",
    /**
     * 外链
     */
    Link = "link"
}

declare enum PrizeType {
    /** 实物 */
    Custom = "custom",
    /** 积分 */
    Score = "score"
}

export declare type ProductClickType = IarProductType | 'delivery';

/**
 * 商品入口位置
 */
export declare enum ProductEntryPosition {
    /** 播放器 */
    Player = "player",
    /** 菜单栏 */
    MenuBar = "menuBar"
}

/**
 * @deprecated 从 v2.6.0 版本开始废弃
 */
export declare interface ProductGoodData {
    /** 商品名称 */
    name: string;
    /** 商品 id */
    productId: string;
    /** 商品原价 */
    realPrice: string;
    /** 自定义价格 */
    customPrice: string;
    /** 价格类型 */
    priceType: string;
    /** 商品价格 */
    price: string;
    /** 商品类型 */
    productType: IarProductType;
    /** 商品提示 */
    productDesc: string;
    /** 推送Id */
    logId?: string;
    /** 购买方式 */
    buyType?: string;
    /** 履约方式 */
    deliveryType?: string;
    /** 推送规则 */
    productPushRule?: string;
    /** 特色标签 */
    features?: string[];
    /** 商品详情 */
    productDetail?: string;
    /** 封面图 */
    cover: string;
    /** 封面图列表 */
    coverList: string[];
    /** 是否开价 */
    openPriceEnable?: string;
    /** 扩展信息 */
    ext?: string;
}

export declare enum ProductGoodExtVideoSource {
    Material = "MATERIAL_LIBRARY"
}

export declare interface ProductHotEffectTips {
    /** 金融商品热卖词 */
    financeProductTips: string;
    /** 普通商品热卖词 */
    jobProductTips: string;
    /** 职位商品热卖词 */
    normalProductTips: string;
}

/**
 * 商品库图标配置
 */
export declare interface ProductIconConfig {
    /**
     * 图标列表
     */
    iconList: string[];
    /**
     * 当前选中的图标
     */
    url: string;
    /**
     * 图标是否显示商品总数
     */
    showProductCount: boolean;
}

export declare interface ProductLinkJumpTipDetail {
    /** 普通商品提示语 */
    ordinaryProductTip: string;
    /** 金融商品提示语 */
    financialProductTip: string;
    /** 职位商品提示语 */
    jobProductTip: string;
}

export declare interface ProductPlaybackData {
    /** 商品回放数据 */
    data: ProductPlaybackItem[];
}

export declare interface ProductPlaybackItem {
    /** 商品库id */
    productId: string;
    /** 回放的时间点，对应播放器播放进度 （毫秒） */
    pushTime: number;
    /** 商品推送id */
    pushId: string;
    /** 卡片类型 在 v2.0.0 版本新增 */
    cardType?: ProductReplayCardType;
}

/**
 * 商品库回放卡片类型
 */
export declare enum ProductReplayCardType {
    BigCard = "bigCard",
    SmallCard = "smallCard"
}

/** 商品回放 map */
export declare interface ProductReplayMap {
    [key: number]: {
        pushId: string;
        productId: string;
        cardType?: ProductReplayCardType;
    };
}

/**
 * 推送流选项
 */
export declare interface PublishStreamOptions extends StreamCommonOptions {
    /**
     * 推流属性
     * @default '240p'
     */
    profile?: StreamProfile;
}

/**
 * 清晰度列表节点
 */
export declare interface QualityLevelItem {
    /** 清晰度类型 */
    type: QualityLevelType;
    /** 级别 */
    level: number;
}

/**
 * 清晰度类型
 */
export declare enum QualityLevelType {
    /**
     * 自动
     */
    auto = "auto",
    /**
     * 流畅
     */
    sd = "sd",
    /**
     * 高清
     */
    hd = "hd",
    /**
     * 超清
     */
    fhd = "fhd"
}

/**
 * 轮训间隔信息
 */
export declare interface QueryFrequencyInfo {
    /** 频道直播状态轮训间隔，单位：秒，默认：10 */
    channelLiveStatusQueryFrequency: number;
    /** pv 接口轮询间隔，单位：秒，默认：20 */
    channelWatchQueryFrequency: number;
    /** 唯一性登录校验轮训间隔，单位：秒，默认：30 */
    channelVerifyQueryFrequency: number;
}

/** 问题答案类型 */
declare type QuestionAnswerType = string | number | string[];

/**
 * 问卷题目数据
 */
declare interface QuestionItem<T extends QuestionItemType = QuestionItemType> {
    /** 题目Id */
    questionId: string;
    /** 题目类型 */
    type: T;
    /** 题目标题 */
    title: string;
    /** 描述 */
    desc?: string;
    /** 是否必填 */
    required?: boolean;
    /** 是否得分题 */
    scoreEnabled?: boolean;
    /** 题目分值 */
    score?: number;
    /** 选项列表 */
    options: QuestionOption[];
    /** 多选题最多可选项数 */
    maxChooseOptions?: T extends QuestionItemType.CheckBox ? number : never;
    /** 多选题最少可选项数 */
    minChooseOptions?: T extends QuestionItemType.CheckBox ? number : never;
    /** 填空题数据 */
    fillQuestionData?: FillQuestionData;
    /** 题目正确答案 */
    rightAnswer?: QuestionAnswerType;
    /** 题目作答人数 */
    answerCount?: number;
}

/**
 * 题目类型
 */
declare enum QuestionItemType {
    /** 多选题 */
    CheckBox = "C",
    /** 单选题 */
    Radio = "R",
    /** 问答题 */
    Question = "Q",
    /** 评星题 */
    Star = "X",
    /** 评分题 */
    Scor = "S",
    /** 判断题 */
    Judgement = "J",
    /** 填空题 */
    Fill = "T",
    /** 投票题 */
    Vote = "V"
}

declare class Questionnaire extends InteractionBase {
    QuestionnaireEvent: typeof QuestionnaireEvent;
    QuestionnaireType: typeof QuestionnaireType;
    QuestionItemType: typeof QuestionItemType;
    SubmitAnswerResult: typeof SubmitAnswerResult;
    eventEmitter: EventEmitter<QuestionnaireEventRelations, QuestionnaireEvent>;
    /** 问题类型记录 */
    private __typeRecord;
    /** 问卷列表 */
    private __questionnaireList;
    constructor(interactionCore: InteractionCore);
    private __processSocketCache;
    /** 发起问卷 socket 处理 */
    private __onStartQuestionnaire;
    /** 停止问卷 socket 处理 */
    private __onStopQuestionnaire;
    /** 问卷统计 socket 处理 */
    private __onSendQuestionnaireResult;
    /** 个人作答 socket 处理 */
    private __onQuestionnaireAchievement;
    /** 问卷排行榜 socket 处理 */
    private __onQuestionnaireRank;
    /**
     * 获取问卷 OSS 数据
     * @param options 获取参数
     * @param options.questionnaireId 问卷 id
     * @param options.internalData 内部数据
     * @param options.ossUrl oss 地址
     * @param options.leftTime 剩余时间
     * @param options.requestLeftTime 是否请求剩余时间
     * @returns 问卷数据
     */
    private __handleQuestionnaireData;
    /**
     * 刷新问卷列表
     */
    refreshQuestionnaireList(): Promise<QuestionnaireBasicData[]>;
    /**
     * 获取当前问卷
     */
    getCurrentQuestionnaire(): Promise<QuestionnaireData | undefined>;
    /**
     * 获取问卷详情
     * @param options 获取参数
     * @param options.questionnaireId 问卷 id
     * @returns 问卷数据
     */
    getQuestionnaireDetail(options: {
        questionnaireId: string;
    }): Promise<QuestionnaireData | undefined>;
    /**
     * 获取问卷列表
     */
    getQuestionnaireList(): QuestionnaireBasicData[];
    /**
     * 提交问卷
     * @param options 提交参数
     * @returns 提交结果
     */
    submitQuestionnaire(options: {
        questionnaireId: string;
        answer: SubmitAnswerData[];
    }): Promise<SubmitAnswerResult>;
    /**
     * 获取题目默认答案
     * @param question 题目数据
     * @returns 默认答案
     */
    getQuestionDefaultAnswer(question: QuestionItem): QuestionAnswerType;
    /**
     * 获取问卷默认答案
     * @param questionnaire 问卷数据
     * @returns 默认答案
     */
    getQuestionnaireDefaultAnswer(questionnaire: QuestionnaireData): Record<string, QuestionAnswerType>;
    /**
     * 检查题目是否完成作答
     * @param question 题目数据
     * @param answer 答案
     * @returns 是否完成
     */
    checkQuestionFinish(question: QuestionItem, answer: QuestionAnswerType | undefined): boolean;
}

/**
 * 问卷基础数据
 */
declare interface QuestionnaireBasicData {
    /** 问卷 id */
    questionnaireId: string;
    /** 问卷标题 */
    questionnaireTitle: string;
    /** 问卷类型 */
    questionnaireType: QuestionnaireType;
}

/**
 * 问卷抽奖条件
 */
declare interface QuestionnaireCondition extends LotteryConditionBase<LotteryCondition.Questionnaire> {
    /**
     * 题目总数
     */
    questionCount: number;
    /**
     * 问卷 id
     */
    questionnaireId: string;
}

/**
 * 问卷数据
 */
declare interface QuestionnaireData {
    /** 问卷 id */
    questionnaireId: string;
    /** 问卷标题 */
    questionnaireTitle: string;
    /** 问卷简介 */
    questionnaireDesc: string;
    /** 问卷类型 */
    questionnaireType: QuestionnaireType;
    /** 隐私协议 */
    privacyContent?: string;
    /** 限制时间，单位：秒 */
    limitTime?: number;
    /** 题目列表 */
    questions: QuestionItem[];
}

declare enum QuestionnaireEvent {
    /**
     * 问卷列表
     */
    QuestionnaireList = "QuestionnaireList",
    /**
     * 开始问卷
     */
    StartQuestionnaire = "StartQuestionnaire",
    /**
     * 结束问卷
     */
    StopQuestionnaire = "StopQuestionnaire",
    /**
     * 问卷统计结果
     */
    QuestionnaireStatistics = "QuestionnaireStatistics",
    /**
     * 问卷作答情况
     */
    QuestionnaireAchievement = "QuestionnaireAchievement",
    /**
     * 问卷排行榜
     */
    QuestionnaireRank = "QuestionnaireRank",
    /**
     * 问卷提交
     */
    SubmitQuestionnaire = "SubmitQuestionnaire"
}

declare type QuestionnaireEventRelations = {
    [QuestionnaireEvent.QuestionnaireList]: {
        /** 问卷列表 */
        questionnaireList: QuestionnaireBasicData[];
    };
    [QuestionnaireEvent.StartQuestionnaire]: {
        /** 问卷数据 */
        questionnaireData: QuestionnaireData;
    };
    [QuestionnaireEvent.StopQuestionnaire]: {
        /** 问卷 id */
        questionnaireId: string;
    };
    [QuestionnaireEvent.QuestionnaireStatistics]: {
        /** 问卷数据 */
        questionnaireData: QuestionnaireData;
        /** 作答情况 */
        questionnaireStatistics: QuestionnaireStatistics;
    };
    [QuestionnaireEvent.QuestionnaireAchievement]: {
        /** 观众作答情况 */
        viewerAnswerResult: ViewerAnswerResult;
    };
    [QuestionnaireEvent.QuestionnaireRank]: {
        /** 问卷 id */
        questionnaireId: string;
        /** 排行榜 */
        rank: QuestionnaireRankData[];
    };
    [QuestionnaireEvent.SubmitQuestionnaire]: {
        /** 问卷 id */
        questionnaireId: string;
    };
};

/**
 * 问卷排行榜数据
 */
declare interface QuestionnaireRankData {
    /** 昵称 */
    nickname: string;
    /** 用户 id */
    viewerId: string;
    /** 头像 */
    avatar?: string;
    /** 答题用时，单位秒 */
    costTime: number;
    /** 得分 */
    score: number;
    /** 是否当前用户 */
    isCurrent: boolean;
    /** 排名 */
    rank: number;
}

/**
 * 问卷统计
 */
declare interface QuestionnaireStatistics {
    questionnaireId: string;
    /** 题目统计，key 为 questionId */
    questionStatistics: Record<string, QuestionStatistics>;
}

/**
 * 问卷类型
 */
declare enum QuestionnaireType {
    /**
     * 调研收集
     */
    Survey = "survey",
    /**
     * 随堂考试
     */
    Exam = "exam",
    /**
     * 问卷抽奖
     */
    Lottery = "lottery"
}

/**
 * 问卷题目选项
 */
declare interface QuestionOption {
    /** 选项序号，大写（A、B、C） */
    id: string;
    /** 选项内容 */
    content: string;
    /** 提示 */
    tips?: string;
    /** 是否正确选项 */
    isRight?: boolean;
    /** 图片 */
    image?: string;
    /** 选项回答人数 */
    answerCount?: number;
    /** 选项回答比例 */
    answerPercent?: number;
}

/**
 * 题目统计
 */
declare interface QuestionStatistics {
    /** 答题人数 */
    answerCount: number;
    /** 选项数据，key 为 选项 id */
    optionData: Record<string, OptionStatistics>;
}

export declare interface RealNameAuthStorageData {
    /** 频道号 */
    channelId: string;
    /** 用户 id */
    userId: string;
    /** 手机号 */
    phoneNumber: string;
    /** 缓存日期时间戳 */
    timestamp: number;
}

export declare enum RealNameFail {
    /** 未知错误 */
    Unknown = "Unknown",
    /** 短信验证码错误 */
    SmsCodeFail = "SmsCodeFail"
}

export declare type RealNameResult = CommonResult<RealNameFail>;

export declare interface RedirectSubChannelData {
    /** 主会场授权成功后，是否跳转回分会场 */
    needRedirectSubChannel: boolean;
    /** 跳转回分会场时的频道号 */
    redirectSubChannelId: string | undefined;
}

/**
 * 重定向到泛域名支付
 */
export declare interface RedirectWatchDomainPayOptions<T extends WatchDomainPayType> {
    /** 支付类型 */
    payType: T;
    /** 参数 */
    params: PickWatchDomainPayParams<T>;
    /** 回调地址 */
    callbackUrl?: string;
}

export declare interface RedirectWeixinAuthorizeUrlOptions extends GetWeixinAuthorizeRedirectUrlOptions {
    /** 跳转的微信授权地址 */
    authorizeRedirectUrl?: string;
}

declare interface RedirectWeixinAuthorizeUrlOptions_2 extends GetWeixinAuthorizeRedirectUrlOptions_2 {
    /** 跳转的微信授权地址 */
    authorizeRedirectUrl?: string;
}

/**
 * @file 红包相关枚举
 */
/**
 * 红包可支付类型
 */
export declare enum RedpackCurrencyType {
    /** 仅现金 */
    Cash = "cash",
    /** 仅积分 */
    Score = "score",
    /** 现金和积分 */
    CashAndScore = "cashAndScore"
}

/**
 * 红包支付类型
 */
export declare enum RedpackPayType {
    /** 仅现金 */
    Cash = "cash",
    /** 仅积分 */
    Score = "score"
}

/**
 * 红包领取记录
 */
export declare interface RedpackReceiveRecord {
    /** 记录 id */
    logId: string;
    /** 领取的金额 */
    amount: number;
    /** 领取者 openId */
    openId: string;
    /** 领取者昵称 */
    nickname: string;
    /** 领取者头像 */
    avatar: string;
    /** 所在的频道号 */
    channelId: string;
    /** 领取时间 */
    receiveTime: string;
    /** 红包类型 */
    redPackType: RedpackType;
}

/**
 * 红包类型
 */
export declare enum RedpackType {
    /**
     * 用户 - 普通红包
     */
    Normal = "normal",
    /**
     * 开播端 - 普通红包
     */
    OfficialNormal = "official_normal",
    /**
     * 开播端 - 口令红包
     */
    Password = "password",
    /**
     * 开播端 - 红包雨
     */
    Rain = "rain",
    /**
     * 开播端 - 积分普通红包
     */
    ScoreOfficialNormal = "score_official_normal",
    /**
     * 开播端 - 积分口令红包
     */
    ScorePassword = "score_password",
    /**
     * 开播端 - 积分红包雨
     */
    ScoreRain = "score_rain",
    /**
     * 开播端 - 积分答题红包
     */
    ScoreQuestion = "score_question",
    /**
     * 开播端 - 答题红包
     */
    Question = "question",
    /**
     * 开播端 - 支付宝口令普通红包
     */
    AlipayPasswordOfficialNormal = "alipay_password_official_normal",
    /**
     * 任务奖励
     */
    TaskWard = "TASK_REWARD"
}

/**
 * 回放字幕列表
 */
export declare interface ReplaySubtitleItem {
    /** 字幕 id */
    id: number;
    /** 字幕名称 */
    name: string | null;
    /** 字幕名称(传递给播放器时) */
    text?: string | null;
    /** 字幕地址 */
    srtUrl: string;
    /** 是否是原声字幕 */
    isOriginal: YN;
    /** 字幕语言 */
    language: SubtitleSourceLanguage | SubtitleSourceTranslateLanguage;
    /** 字幕来源 */
    source: string;
}

/**
 * 请求授权方式
 */
declare enum RequestAuthorizeMethod {
    /** 通过令牌授权 */
    Token = "token",
    /** 通过签名授权 */
    Sign = "sign"
}

export declare interface ReSendMsgOptions extends SendMsgOptions {
    /**
     * 是否仅发送本地消息
     * @default false
     */
    onlyLocalMsg?: boolean;
}

/**
 * 失败结果
 */
export declare interface ResultFail<FailReason extends string> {
    success: false;
    /** 失败原因 */
    failReason: FailReason;
    /** 失败消息 */
    failMessage?: string;
}

/**
 * 失败结果
 */
declare interface ResultFail_2<FailReason extends string> {
    success: false;
    /** 失败原因 */
    failReason: FailReason;
    /** 失败消息 */
    failMessage?: string;
}

/**
 * 失败结果
 */
declare interface ResultFail_3<FailReason extends string> {
    success: false;
    /** 失败原因 */
    failReason: FailReason;
    /** 失败消息 */
    failMessage?: string;
}

export declare type ResultSuccess<SuccessData extends object = object> = ResultSuccessBasic & SuccessData;

declare type ResultSuccess_2<SuccessData extends object = object> = ResultSuccessBasic_2 & SuccessData;

declare type ResultSuccess_3<SuccessData extends object = object> = ResultSuccessBasic_3 & SuccessData;

/**
 * 成功的结果
 */
export declare interface ResultSuccessBasic {
    success: true;
}

/**
 * 成功的结果
 */
declare interface ResultSuccessBasic_2 {
    success: true;
}

/**
 * 成功的结果
 */
declare interface ResultSuccessBasic_3 {
    success: true;
}

export declare interface RewardAcceptFormItem {
    /** 表单类型 */
    type: RewardAcceptFormType;
    /** 字段名 */
    field: string;
    /** 提示 */
    tips: string;
    /** 是否必填 */
    required: boolean;
    /** 提交内容 */
    value?: string;
}

export declare enum RewardAcceptFormType {
    /** 姓名 */
    UserName = "userName",
    /** 手机 */
    UserPhone = "userPhone",
    /** 自定义 */
    Custom = "custom",
    /** 地址 */
    Address = "address"
}

export declare enum RewardAcceptType {
    /** 表单领取 */
    Form = "form",
    /** 跳转链接 */
    Link = "link",
    /** 二维码 */
    QrCode = "qrCode"
}

/**
 * 表单类型
 */
declare type RewardReceiveFormType = 'input' | 'phone' | 'address';

declare interface RtasConfig {
    /**
     * 项目名称
     */
    projectName?: ProjectName;
    /**
     * 应用名称
     */
    appName?: string;
    /**
     * 应用版本
     */
    appVersion?: string;
    /**
     * 授权方式
     */
    logonType?: string;
}

export { RtasTrackEventCata }

/** 数据上报事件 id */
export declare type RtasTrackEventId = 
/** 商品列表入口点击事件 */
'product_cart_click'
/** 订单页浏览事件 */
| 'order_page_visit'
/** 观看页浏览事件 */
| 'watch_page_view'
/** 用户打开商品库 */
| 'user_click_product_list'
/** 用户预约直播 */
| 'user_reservation_live'
/** 用户点击邀请海报 */
| 'user_click_poster'
/** 用户提现 */
| 'user_withdrawal'
/** 用户浏览红包 */
| 'user_read_redpack'
/** 用户查看二维码 */
| 'user_watch_qrcode'
/** 用户点击关注按钮 */
| 'user_click_interest'
/** 用户点赞 */
| 'user_click_live'
/** 用户预约直播 */
| 'user_reservation_live'
/** 用户确认预约 */
| 'user_confirm_reservation_live'
/** 用户登记报名 */
| 'user_register_application';

export { RtasTrackEventType }

/** 数据上报页面类型 */
export declare type RtasTrackPageType = 'saas-web-splash-pc' | 'saas-web-splash-mobile' | 'saas-web-watch-pc' | 'saas-web-watch-mobile' | 'saas-web-watch-portrait';

/**
 * RTC 供应商缩写
 */
export declare enum RtcAbridgeType {
    /** 声网 */
    Agora = "A",
    /** UCloud */
    UCloud = "U",
    /** 腾讯 */
    Tencent = "T",
    /** 火山 */
    VolcEngine = "V"
}

declare interface RtcChannelJsonInstance {
    data?: PlayerChannelJsonData;
    request(): Promise<PlayerChannelJsonData>;
    checkSign(): Promise<{
        status: 'success' | 'error';
        msg?: string;
    }>;
    getMarqueeData(): MarqueeData$1 | undefined;
}

declare interface RtcStreamCommonOptions {
    /** 渲染节点 */
    element: HTMLDivElement;
    /** 控制栏 */
    control?: boolean;
    /** 播放配置 */
    playConfig?: StreamPlayOptions;
    /** 播放回调 */
    playCallBack?: (err: string) => void;
}

/**
 * @file rtc 相关的枚举
 */
/** RTC 供应商 */
export declare enum RtcType {
    /** 声网 */
    Agora = "agora",
    /** UCloud */
    UCloud = "urtc",
    /** 腾讯 */
    Tencent = "trtc",
    /** 火山 */
    VolcEngine = "volc"
}

/**
 * 类型关系
 */
export declare const rtcTypeRelation: Record<RtcType, RtcAbridgeType>;

declare type RtcWebSdkEvents = 'OPEN_MICROPHONE' | 'CLOSE_MICROPHONE' | 'JOIN_CHANNEL_TIMEOUT' | 'ALLOW_MICROPHONE' | 'INIT_LOCAL_STREAM_READY' | 'INIT_LOCALSTREAM_SUCCESS' | 'INIT_LOCALSTREAM_ERROR' | 'PUBLIC_STREAM_SUCCESS' | 'PUBLIC_STREAM_ERROR' | 'LEAVE_CHANNEL_SUCCESS' | 'CLIENT_BANNED' | 'USER_STREAM_ADDED' | 'USER_PEER_LEAVE' | 'USER_MUTE_AUDIO' | 'USER_UNMUTE_AUDIO' | 'USER_MUTE_VIDEO' | 'USER_UNMUTE_VIDEO' | 'LOCAL_MUTE_AUDIO' | 'LOCAL_UNMUTE_AUDIO' | 'LOCAL_MUTE_VIDEO' | 'LOCAL_UNMUTE_VIDEO' | 'SWITCH_MASTER' | 'NETWORK_QUALITY' | 'INVITE_TO_MICROPHONE' | 'ANSWER_MICROPHONE_INVITE' | 'OVER_JOIN_LIMIT' | 'SCREEN_SHARE_STOP' | 'MUTE_VIDEO_BANNED' | 'DEVICE_AUTO_RECOVER_FAILED' | 'ERROR_NOTIFY' | 'FACING_MODE_CHANGE' | 'USER_STREAM_PLAY_FAILED' | 'LEAVE_AUDIENCE' | 'INVITE_COUNT_DOWN' | 'LOCAL_MUTE_STATUS_CHANGE';

/**
 * 连麦 rtc 实例
 */
declare interface RtcWebSdkInstance {
    /** rtc实例 */
    chat: {
        initClient(opts: {
            mode: string;
            codec: string;
            role: string;
        }): Promise<void>;
        startPlayPublicStream(config: {
            elementId: string;
        }): Promise<VEPublicSrteam>;
        stopPlayPublicStream(): Promise<void>;
        onClient(evt: 'PUBLIC_NETWORK_QUALITY', func: (evt: {
            downlinkNetworkQuality: DownlinkNetworkQuality;
        }) => void): void;
    };
    /** 打开设备设置 */
    openDeviceSetting(): void;
    /** 关闭设备设置 */
    closeDeviceSetting(): void;
    /** 获取设备权限 */
    getDevicePermission(checkType?: ConnectMicType): Promise<boolean>;
    /** 打开邀请窗口 */
    openInviting(enforceVideo?: boolean, autoConnect?: boolean): void;
    /** 关闭邀请窗口 */
    closeInviting(): void;
    /** 接受邀请上麦 */
    acceptInvite(autoConnect?: boolean): void;
    /** 拒绝邀请上麦 */
    refuseInvite(): void;
    /** 获取邀请上麦倒计时 */
    getInviteCountDown(): InviteCountDownData;
    /** 获取设备列表 */
    getDevicesList(): Promise<{
        audioDevices: MediaDeviceInfo[];
        videoDevices: MediaDeviceInfo[];
    }>;
    /**
     * 查询当前本地音视频的静音状态（true 表示已关闭/静音）
     * 与 setLocalMuteStatus 对称：
     * - 已连麦：取底层推流的实时状态
     * - 未连麦（含预览阶段）：取设备预设值，acceptInvite 后将沿用
     */
    getLocalMuteStatus(): {
        video: boolean;
        audio: boolean;
    };
    /** 获取当前设备 ID */
    getCurrentDeviceId(): {
        microphoneId: string;
        cameraId: string;
        facingMode?: FacingMode;
    };
    /**
     * 切换本地输入设备
     * 未连麦时仅记录设备 id，下一次推流（acceptInvite/publish）时生效；
     * 已连麦时会调用底层 SDK 的换轨能力实时切换。
     * @param type   'audio' 切麦克风，'video' 切摄像头
     * @param deviceId 设备 id
     * @param callback 切换成功回调
     */
    switchLocalDevice(type: 'audio' | 'video', deviceId: string, callback?: (type: 'audio' | 'video') => void): void;
    /**
     * 预设/调整本地音视频开关
     * - 尚未推流时：仅写入预设值，acceptInvite/publish 后生效
     * - 已推流时：等价于直接调用 enable/disable 对应轨道
     * @param option { video?: boolean; audio?: boolean } true 表示静音/关闭
         */
     setLocalMuteStatus(option: {
         video?: boolean;
         audio?: boolean;
     }): void;
     /** 开始本地预览 */
     startPreview(config: PreviewConfig): Promise<PreviewHandle>;
     /** 停止本地预览 */
     stopPreview(): void;
     /** 获取本地预览音量 0~1 */
     getPreviewVolume(): number;
     /** 是否正在预览 */
     isPreviewing(): boolean;
     /** 申请连麦 */
     joinChannel(): void;
     /** 取消申请连麦 */
     cancelJoinChannel(): void;
     /** 离开连麦房间 */
     leaveChannel(): void;
     /** 立即上麦 */
     publish(): Promise<void>;
     /** 移除流 */
     remove(streamId: string): void;
     /** 播放流 */
     play(streamId: string, options: RtcStreamCommonOptions): void;
     /** 恢复所有流播放 */
     resumeAllStreams(): Promise<void>;
     /** 开启摄像头 */
     enableVideo(): void;
     /** 关闭摄像头 */
     disableVideo(): void;
     /** 开启麦克风 */
     enableAudio(): void;
     /** 关闭麦克风 */
     disableAudio(): void;
     /** 切换语言 */
     updateLang(lang: string): void;
     /** 开始屏幕共享 */
     startScreenShare(mode: ScreenShareMode, audioMixEnabled: boolean): Promise<void>;
     /** 结束屏幕共享 */
     stopScreenShare(): Promise<void>;
     /** 进入画中画 */
     enterPip(callback: (isEnter: boolean) => void): Promise<void>;
     /** 退出画中画 */
     exitPip(): Promise<void>;
     /** 更新统计信息 */
     updateSession(config: StatParams): string | false;
     /** 启动小班课统计 */
     startClassStat(forceNew?: boolean): boolean;
     /** 停止小班课统计 */
     stopClassStat(): void;
     /** 暂停小班课统计（暂停 pd 累加） */
     pauseClassStat(): void;
     /** 恢复小班课统计（恢复 pd 累加） */
     resumeClassStat(): void;
     /** 更新小班课统计配置 */
     updateClassStatConfig(config: StatParams): string | false;
     /** 获取小班课统计状态 */
     getClassStatStatus(): ClassStatStatus | null;
     /** 更新用户名 */
     changeUsername(nick: string): void;
     /** 获取是否支持切换前后摄像头 */
     getFacingModeSupport(): boolean;
     /** 切换前后摄像头 */
     changeFacingMode(facingMode: FacingMode): void;
     /** 获取当前前后摄像头 */
     getCurrentFacingMode(): FacingMode;
     /** 监听事件 */
     on(event: RtcWebSdkEvents, fn: (...args: any[]) => void): void;
     /** 类似观众的身份去订阅讲师流（仅订阅不推流） */
     joinAsAudience(): Promise<void>;
     /** 是否已加入观众模式 */
     audienceModeJoined: boolean;
     /** 离开观众模式 */
     leaveAudience(): Promise<void>;
     /** 销毁 */
     destroy(): void;
    }

    /**
     * 连麦 rtc 实例化选项
     * @link {rtc-web-SDK SDKConfig}
     */
    declare interface RtcWebSdkOptions {
        /** 房间号 */
        roomId: string;
        /** 聊天室用户 id */
        userId: string;
        /** 昵称 */
        nick: string;
        /** 头像 */
        pic: string;
        /** 聊天室 socket 对象 */
        socket?: SocketIOClient.Socket;
        /** 聊天室用户身份 */
        userType: ChatUserType;
        /** 类型 */
        type: RtcAbridgeType;
        /** 语言 */
        lang?: string;
        /** 直播API自定义域名 */
        apiHostLive?: string;
        /** 聊天室API自定义域名 */
        apiHostChat?: string;
        /** 无延迟观看模式 */
        lowLatency?: boolean;
        /** 页面隐藏是否停止发送统计 */
        pageHiddenStopStat?: boolean;
        /** 无延迟统计参数 */
        lowLatencyStat?: StatConfig;
        /** 小班课统计配置 */
        classStat?: ClassStatConfig;
        /** 只播放火山公共流 */
        isOnlyPublic?: boolean;
        /**  CLOSE_MICROPHONE 事件触发是否不退出连麦 */
        disableRtcCloseEvent?: boolean;
        /** 摄像头异常是否使用麦克风上麦 */
        cameraErrorRetryAudio?: boolean;
    }

    /** SaaS 观看页入口信息 */
    declare interface SaaSWatchEntranceInfo {
        /** 保利威账号Id */
        userId?: string;
        tokenRequestMode?: PolyvWatchApiTokenRequestMode_2;
        allowSwitchLangEnabled?: YN;
        watchLangType?: 'follow_browser' | LanguageType;
        padLayout?: TabletLayoutSetting;
        /** 是否随机处理分享域名 */
        randomShareDomainEnabled?: YN;
    }

    /**
     * 保存实名认证信息参数
     */
    export declare interface SaveRealNameOptions {
        /**
         * 手机区号
         */
        areaCode: string;
        /**
         * 手机号
         */
        phoneNumber: string;
        /**
         * 短信验证码
         */
        smsCode: string;
    }

    /** 积分红包配置 */
    export declare interface ScoreRedpackConfig {
        /** 是否可以使用积分红包 */
        scoreRedpackEnabled: boolean;
        /** 积分单位 */
        scoreUnit: string;
    }

    /**
     * 屏幕共享配置
     */
    export declare interface ScreenShareConfig {
        /**
         * 共享模式
         */
        screenShareMode?: ScreenShareMode;
        /**
         * 混音开关
         */
        audioMixEnabled?: boolean;
    }

    /**
     * 屏幕共享异常原因
     */
    export declare enum ScreenShareError {
        /**
         * 未知
         */
        Unknown = "Unknown",
        /**
         * 当前环境不支持屏幕共享
         */
        BrowserNotSupport = "BrowserNotSupport",
        /**
         * 当前频道不支持屏幕共享
         */
        ChannelNotSupport = "ChannelNotSupport",
        /**
         * 用户权限被拒绝
         */
        PermissionDenied = "PermissionDenied",
        /**
         * 系统权限被拒绝
         */
        SystemPermissionDenied = "SystemPermissionDenied",
        /**
         * 屏幕共享中，无法设置屏幕共享配置
         */
        ScreenShareing = "ScreenShareing"
    }

    /**
     * 屏幕共享信息
     */
    export declare interface ScreenShareInfo {
        /**
         * 当前环境是否支持屏幕共享
         */
        supportScreenShare: boolean;
        /**
         * 屏幕共享模式
         */
        screenShareMode: ScreenShareMode;
        /**
         * 屏幕共享混音开关
         */
        audioMixEnabled: boolean;
        /**
         * 当前是否屏幕共享中
         */
        isScreenSharing: boolean;
        /**
         * 当前环境是否支持画中画
         */
        supportPip: boolean;
        /**
         * 当前是否正在画中画
         */
        isPiping: boolean;
    }

    /**
     * 屏幕共享模式
     */
    export declare enum ScreenShareMode {
        /**
         * 静态画面为主（适合共享文字、文档）
         */
        Detail = "detail",
        /**
         * 动态画面为主（适合共享多媒体视频）
         */
        Motion = "motion"
    }

    /**
     * 屏幕共享结果
     */
    export declare type ScreenShareResult = CommonResult<ScreenShareError>;

    /**
     * 集成 SDK 配置
     */
    declare interface SdkIntegrationConfig {
        /** 互动功能 sdk 层 js 地址 */
        interactionSdkScriptUrl?: SdkLoaderScriptType;
        /** 直播播放器 js 地址 */
        livePlayerScriptUrl?: SdkLoaderScriptType;
        /** 无延迟直播播放器 js 地址 */
        liveLowLatencyPlayerScriptUrl?: SdkLoaderScriptType;
        /** 点播播放器 js 地址 */
        vodPlayerScriptUrl?: SdkLoaderScriptType;
        /** 连麦 sdk js 地址 */
        rtcWebScriptUrl?: SdkLoaderScriptType;
        /**
         * 聊天室功能 sdk 层 js 地址
         * @version v0.12.0
         * */
        chatSdkScriptUrl?: SdkLoaderScriptType;
        /**
         * 登录认证功能 sdk 层 js 地址
         * @version v2.0.0
         */
        watchIdentifySdkScriptUrl?: SdkLoaderScriptType;
        /**
         * 新版互动 sdk 层对用的 js 地址配置
         * @version v2.0.0
         */
        iarSdkScriptConfig?: IarSdkScriptConfig;
        /**
         * 商品 SDK js 地址
         * @version v2.4.0
         */
        productSdkScriptUrl?: SdkLoaderScriptType;
        /**
         * Watch AI SDK 层 js 地址
         * @version v2.7.0
         */
        watchAISdkScriptUrl?: SdkLoaderScriptType;
        /**
         * 新版聊天室功能 sdk 层 js 地址
         * @version v2.9.0
         */
        chatSdkV2ScriptUrl?: SdkLoaderScriptType;
        /**
         * 新版 socket 功能 sdk 层 js 地址
         * @version v2.9.0
         */
        socketScriptUrl?: SdkLoaderScriptType;
    }

    /** SDK 加载环境 */
    export declare enum SdkLoaderEnv {
        /** 生产环境 */
        Prod = "prod",
        /** 预览/灰度环境 */
        Rc = "rc",
        /** 测试环境 */
        Test = "test"
    }

    /** SDK 的 js 地址类型 */
    declare type SdkLoaderScriptType = string | (() => string);

    declare interface SearchUserListOptions {
        /**
         * 搜索关键词
         */
        keyword: string;
    }

    /** 云席模板 */
    export declare enum SeatTableTemplate {
        /** 模拟会场 */
        Meeting = "meeting",
        /** 竖向列表 */
        Vertical = "vertical"
    }

    /**
     * 安全模式
     */
    declare enum SecurityMode {
        /** 不使用 */
        None = "none",
        /** AES 加密解密 */
        AES = "aes",
        /** SM2 加密解密 */
        SM2 = "sm2"
    }

    declare interface SendAIQuestionMsgOptions {
        /** 提问内容 */
        content: string;
    }

    /**
     * 发送提问图片消息
     */
    export declare interface SendAskImageOptions {
        /** 图片 id */
        imageId: string;
        /** 图片地址 */
        imageUrl: string;
        /** 图片尺寸 */
        size?: {
            width: number;
            height: number;
        };
    }

    /**
     * 发送提问发言消息
     */
    export declare interface SendAskSpeakOptions {
        /** 发言内容 */
        content: string;
    }

    /**
     * 发送自定义消息(客户端)选项
     */
    export declare interface SendCustomMessageOptions<T extends object = object> {
        /** 自定义事件，默认为 'client-custom' */
        EVENT?: string;
        /** 自定义数据，但需要传入一个对象 */
        data: T;
        /** 自定义版本，默认为 1 */
        version?: number;
        /** 自定义提示，默认为空 */
        tip?: string;
        /** 是否加入聊天历史数据, 默认为 true */
        joinHistoryList?: boolean;
    }

    /**
     * 发送图片表情参数
     */
    export declare interface SendEmotionImageMsgOptions extends SendMsgOptions {
        /**
         * 表情 id
         */
        emotionId: string;
        /**
         * 表情图片地址
         */
        emotionUrl: string;
    }

    /**
     * 发送图片参数
     */
    export declare interface SendImageMsgOptions extends SendMsgOptions {
        /**
         * 图片 id，建议使用 uuid(v4) 生成
         */
        imageId: string;
        /**
         * 图片地址
         */
        imageUrl: string;
        /**
         * 图片尺寸
         */
        size?: {
            width: number;
            height: number;
        };
    }

    export declare interface SendMsgOptions {
        /**
         * 强制发送，忽略禁言判断
         * @default false
         */
        forceSend?: boolean;
    }

    /**
     * 发送消息结果
     */
    export declare interface SendMsgResult<M extends ChatMsgType> {
        /**
         * 本地 id
         */
        localId: string;
        /**
         * 聊天消息
         */
        chatMsg: M;
    }

    /** 获取发红包的配置 */
    export declare interface SendRedpackConfig {
        /** 是否可以发红包 */
        sendRedpackEnabled: boolean;
        /** 观众发红包最大金额限制 */
        sendRedpackMaxAmount: number;
        /** 观众发红包最大数量限制 */
        sendRedpackMaxCount: number;
        /** 观众发红包最低均分 */
        sendRedpackMinAverage: number;
    }

    declare enum SendRedpackFailReason {
        /** 未知 */
        Unknown = "Unknown",
        /** 发送失败 */
        SendFail = "SendFail"
    }

    export declare enum SendSmsVerifyCodeFail {
        /**
         * 未知错误
         */
        Unknown = "Unknown",
        /**
         * 图片验证码错误
         */
        ImageCaptchaError = "ImageCaptchaError",
        /**
         * 发送频繁
         * @version v0.6.0
         */
        SendFrequent = "SendFrequent",
        /**
         * 没有设置短信平台
         * @version v0.8.0
         */
        UnSetSmsPlatform = "UnSetSmsPlatform"
    }

    declare enum SendSmsVerifyCodeFail_2 {
        /**
         * 未知错误
         */
        Unknown = "Unknown",
        /**
         * 图片验证码错误
         */
        ImageCaptchaError = "ImageCaptchaError",
        /**
         * 发送频繁
         * @version v0.6.0
         */
        SendFrequent = "SendFrequent",
        /**
         * 没有设置短信平台
         * @version v0.8.0
         */
        UnSetSmsPlatform = "UnSetSmsPlatform"
    }

    export declare type SendSmsVerifyCodeParams = SendSmsVerifyCodeParamsImage | SendSmsVerifyCodeParamsSlider | SendSmsVerifyCodeParamsNone;

    declare type SendSmsVerifyCodeParams_2 = SendSmsVerifyCodeParamsImage_2 | SendSmsVerifyCodeParamsSlider_2 | SendSmsVerifyCodeParamsNone_2;

    export declare interface SendSmsVerifyCodeParamsCommon<T extends SmsValidType> {
        /** 手机号 */
        phoneNumber: string;
        /** 区号 */
        areaCode: string;
        /** 验证类型 */
        validType: T;
        /** 场景 */
        scene: SmsScene;
    }

    declare interface SendSmsVerifyCodeParamsCommon_2<T extends SmsValidType_2> {
        /** 手机号 */
        phoneNumber: string;
        /** 区号 */
        areaCode: string;
        /** 验证类型 */
        validType: T;
        /** 场景 */
        scene: SmsScene_2;
    }

    /**
     * 发送短信验证码参数（图片验证码验证）
     */
    export declare interface SendSmsVerifyCodeParamsImage extends SendSmsVerifyCodeParamsCommon<SmsValidType.Image>, ImageCaptchaParams {
    }

    /**
     * 发送短信验证码参数（图片验证码验证）
     */
    declare interface SendSmsVerifyCodeParamsImage_2 extends SendSmsVerifyCodeParamsCommon_2<SmsValidType_2.Image>, ImageCaptchaParams_2 {
    }

    /**
     * 发送短信验证码参数（无验证）
     */
    export declare interface SendSmsVerifyCodeParamsNone extends SendSmsVerifyCodeParamsCommon<SmsValidType.None> {
    }

    /**
     * 发送短信验证码参数（无验证）
     */
    declare interface SendSmsVerifyCodeParamsNone_2 extends SendSmsVerifyCodeParamsCommon_2<SmsValidType_2.None> {
    }

    /**
     * 发送短信验证码参数（滑块验证码验证）
     */
    export declare interface SendSmsVerifyCodeParamsSlider extends SendSmsVerifyCodeParamsCommon<SmsValidType.Slider>, SliderCaptchaParams {
    }

    /**
     * 发送短信验证码参数（滑块验证码验证）
     */
    declare interface SendSmsVerifyCodeParamsSlider_2 extends SendSmsVerifyCodeParamsCommon_2<SmsValidType_2.Slider>, SliderCaptchaParams_2 {
    }

    /**
     * 发送短信验证码的结果
     */
    export declare type SendSmsVerifyResult = CommonResult<SendSmsVerifyCodeFail>;

    /**
     * 发送短信验证码的结果
     */
    declare type SendSmsVerifyResult_2 = CommonResult_3<SendSmsVerifyCodeFail_2>;

    /**
     * 发言参数
     */
    export declare interface SendSpeakMsgOptions extends SendMsgOptions {
        /**
         * 发言内容
         */
        content: string;
        /**
         * 是否仅发送本地消息
         * @default false
         */
        onlyLocalMsg?: boolean;
        /**
         * 引用的消息
         */
        quoteMsg?: ChatMsgQuoteOriginType;
    }

    /**
     * 设置调试模式
     * @param isDebug 调试模式
     */
    export declare function setDebugMode(isDebug?: boolean): void;

    /**
     * 设置调试模式
     * @param isDebug 调试模式
     */
    declare function setDebugMode_2(isDebug?: boolean): void;

    /**
     * 设置弹幕选项
     */
    export declare interface SetupBarrageOptions {
        /** 渲染的容器 */
        container: HTMLDivElement;
        /**
         * 接收到聊天消息时是否自动插入到弹幕中，如果传入 false 则不会自动插入
         * @default true
         */
        autoAdd?: boolean;
        /** 弹幕速度 */
        speed?: number;
        /** 弹幕字号 */
        size?: number;
        /** 弹幕透明度 */
        alpha?: number;
        /** 弹幕显示方向 */
        areaDirection?: IDirection;
        /** 弹幕显示百分比 */
        areaPercentage?: number;
        /** 显示回调 */
        onShowCallback?: () => void;
        /** 隐藏回调 */
        onHideCallback?: () => void;
    }

    /**
     * 设置文档选项
     */
    export declare interface SetupDocOptions {
        /** 渲染节点 */
        container: HTMLDivElement;
        /** 语言，默认：zh_CN */
        language?: 'zh_CN' | 'en';
        /** 键盘控制开关，默认：true */
        keyboardEnabled?: boolean;
        /** 是否显示移动端全屏，默认：true */
        mobileFullScreenVisible?: boolean;
        /** 清空拦截 */
        beforeClear?: () => Promise<void>;
    }

    declare interface SetupDocPlaybackOptions {
        /** 回放类型，暂存或直播 */
        type: 'playback' | 'record';
        /** 暂存时的文件 id */
        fileId?: string;
        /** 回放时的 videoId */
        videoId?: string;
    }

    /**
     * 创建跑马灯参数
     */
    export declare interface SetupMarqueeOptions {
        /**
         * 容器节点
         */
        container: HTMLDivElement;
    }

    /**
     * 创建播放器参数
     */
    export declare interface SetupPlayerOptions {
        /**
         * 创建容器
         */
        container: HTMLDivElement;
        /**
         * 是否使用无延迟播放
         * @default false
         */
        lowLatency?: boolean;
        /**
         * 回放参数
         */
        playbackOptions?: SetupPlayerPlaybackOptions;
        /**
         * 是否自动播放
         * @default 根据后台设置
         */
        autoplay?: boolean;
        /**
         * 弹幕功能开关
         * @default 根据后台设置
         */
        barrageEnabled?: boolean;
        /**
         * 弹幕默认是否显示
         * @default 根据后台设置
         */
        barrageShow?: boolean;
        /**
         * 弹幕速度
         * @default 根据后台设置
         */
        barrageSpeed?: number;
        /**
         * 弹幕字号
         * @default 根据后台设置
         */
        barrageSize?: number;
        /**
         * 弹幕位置对应的显示方向
         * @default 默认顶部, 自上向下
         */
        barrageDirection?: IDirection;
        /**
         * 弹幕位置对应的显示百分比, 取值范围0~1
         * @default 默认顶部, 1/4
         */
        barragePercent?: number;
        /**
         * 弹幕位置对应的ID
         * @default 默认顶部, 0
         */
        barrageLocationId?: number;
        /**
         * 弹幕透明度, 取值范围0~100
         * @default 默认80
         */
        barrageAlpha?: number;
        /**
         * 自动监听消息事件添加弹幕
         * @default true
         */
        barrageAutoAdd?: boolean;
        /**
         * 语言，0-中文，1-英文
         * @default 0
         */
        language?: 0 | 1 | string;
        /**
         * 双语流功能
         * @default 根据后台设置
         */
        languageStreamEnabled?: boolean;
        /**
         * 流多轨 Key 值
         * @desc 需要{@link languageStreamEnabled} 为 true 才会生效
         */
        streamTrackKey?: string;
        /**
         * 是否显示控制栏
         * @default true
         */
        showController?: boolean;
        /**
         * 皮肤设置
         */
        skinConfig?: LivePlayerUISkinConfig;
        /**
         * 全屏模式
         * @default 根据后台配置
         */
        fullScreenMode?: FullScreenMode;
        /**
         * 显示音频切换，仅移动端支持
         * @default 根据后台配置
         */
        audioSwitchEnabled?: boolean;
        /**
         * 是否禁用片头广告
         * @default false
         */
        banHeaderAdvertisement?: boolean;
        /**
         * 是否禁用播放密码
         * @default false
         */
        banPassword?: boolean;
        /**
         * 是否自动切换回放(仅支持直播暂存视频)
         * @version v0.5.1
         * @desc 从 v1.0.0 版本也支持常规回放视频
         * @default false
         */
        autoChangePlayback?: boolean;
        /**
         * 额外的播放器选项，会直接传给播放器 SDK ，请自行参考相关的选项配置
         * @version v0.4.0
         * @internal
         */
        extraPlayerOptions?: {
            [key: string]: unknown;
        };
        /**
         * 自定义的直播流 token， 设置后会在拉流地址的 query 参数中添加 `token` 参数
         * @version v2.4.0
         */
        liveStreamToken?: string;
        /**
         * 直播状态为非直播时，是否直接显示暂无直播，优先比暖场要高
         * @internal
         * @version v2.5.0
         */
        directPlayCutOff?: boolean;
        /**
         * 安卓增强全屏模式
         * @version v2.5.0
         */
        useFullscreenApi?: boolean;
        /**
         * 自定义全屏元素, 开启 useFullscreenApi 后生效，仅移动端生效, 使用前建议咨询技术支持
         * @version v2.5.0
         */
        customFullscreenElement?: Element;
        /**
         * 低延迟智能播放开关, 默认读频道配置
         * @version v2.5.0
         */
        lowLatencyIntelligentPlayEnabled?: boolean;
        /**
         * 自定义片头/暂停广告点击
         * @version 2.7.0
         */
        customAdvertClick?: boolean;
        /**
         * 是否使用播放器缓冲检测，默认开
         * @version v2.8.0
         */
        useLoadingDetection?: boolean;
    }

    export declare type SetupPlayerPlaybackOptions = SetupPlayerPlaybackOptionsByRecord | SetupPlayerPlaybackOptionsByPlayback | SetupPlayerPlaybackOptionsByVod | SetupPlayerPlaybackOptionsByMaterial;

    /** 回放参数（素材库） */
    export declare interface SetupPlayerPlaybackOptionsByMaterial extends SetupPlayerPlaybackOptionsCommon {
        type: PlaybackType.Material;
        /** 回放 vid */
        vid: string;
        /** 直播回放 id */
        videoId: string;
        /** 回放地址（必有） */
        url: string;
        /** 回放总时长 */
        duration?: number;
        /** 裁减场次号 */
        clipSessionId?: string;
    }

    /** 回放参数（回放） */
    export declare interface SetupPlayerPlaybackOptionsByPlayback extends SetupPlayerPlaybackOptionsCommon {
        type: PlaybackType.Playback;
        /** 回放 vid */
        vid: string;
        /** 直播回放 id */
        videoId: string;
        /** 回放地址（必有） */
        url: string;
        /** 回放总时长 */
        duration?: number;
        /** 裁减场次号 */
        clipSessionId?: string;
    }

    /** 回放参数（暂存） */
    export declare interface SetupPlayerPlaybackOptionsByRecord extends SetupPlayerPlaybackOptionsCommon {
        type: PlaybackType.Record;
        /** 回放总时长 */
        duration?: number;
        /** 裁减场次号 */
        clipSessionId?: string;
    }

    /** 回放参数（点播） */
    export declare interface SetupPlayerPlaybackOptionsByVod extends SetupPlayerPlaybackOptionsCommon {
        type: PlaybackType.Vod;
        /** 点播 vid */
        vid: string;
        /** 直播回放 id */
        videoId: string;
        /** 是否需要点播加密 */
        seed?: boolean;
    }

    export declare interface SetupPlayerPlaybackOptionsCommon {
        /**
         * ppt 回放的文件 id
         * @version v0.9.0 点播在该版本才有这个字段
         */
        fileId: string;
        /**
         * 视频资源地址
         * @version v0.6.0
         * */
        videoSource: PlaybackVideoSource;
        /**
         * 回放地址
         */
        url?: string;
        /**
         * 回放的场次号
         */
        sessionId: string;
    }

    export declare interface SetupWatermarkOptions {
        /** 外层的 div 容器 */
        container: HTMLDivElement;
    }

    /**
     * 支持配置观看页入口信息
     * @version v2.0.0
     * @desc 注意，仅支持设置一次，如果已有入口信息，将不会设置成功
     */
    export declare function setWatchEntranceInfo(entranceInfo: SaaSWatchEntranceInfo): void;

    export declare interface ShareSetting {
        /** 是否支持分享 */
        shareEnabled: boolean;
        /** 是否支持回放标题分享 */
        playbackShareTitleEnabled: boolean;
        /** 是否使用自定义分享链接 */
        isUseCustomShareUrl: boolean;
        /** 自定义分享链接(网页分享) */
        customShareUrl: string;
        /** 是否使用自定义分享链接追加参数 */
        customShareUrlAppendParamsEnabled: boolean;
    }

    /**
     * 简单的宽高类型
     */
    export declare interface SimpleSize {
        width: number;
        height: number;
    }

    export declare interface SliceIdSpeakTop {
        /** 上墙信息 */
        content: string;
        /** 上墙id */
        id: string;
        /** 昵称 */
        nick: string;
        /** 头像 */
        pic: string;
        /** 操作者头衔 */
        topActor: string;
        /** 用户身份 */
        userType?: ChatUserType;
        /** 用户头衔 */
        actor?: string;
        /** 聊天回放动作 */
        action?: ChatReplaySpeakTopAction;
        /** 其他评论上墙的数据 */
        others?: Omit<SliceIdSpeakTop, 'others'>[];
    }

    export declare interface SliderCaptchaParams {
        [key: string]: unknown;
    }

    declare interface SliderCaptchaParams_2 {
        [key: string]: unknown;
    }

    /**
     * SM2 密钥
     */
    declare interface SM2Key {
        /**
         * 平台公钥（接口提交参数加密用）
         */
        platformPublicKey: string;
        /**
         * 用户私钥（接口响应内容解密用）
         */
        userPrivateKey: string;
    }

    /**
     * 短信预约信息
     */
    export declare interface SmsBooking {
        /** 是否正在预约 */
        booking: YN;
        /** 短信预约开关 */
        bookingEnabled: YN;
    }

    /**
     * 短信全局配置
     */
    export declare interface SmsConfig {
        /** 短信图片验证码是否可用，默认 true */
        smsImageCaptchaEnabled: boolean;
    }

    /**
     * 短信全局配置
     */
    declare interface SmsConfig_2 {
        /** 短信图片验证码是否可用，默认 true */
        smsImageCaptchaEnabled: boolean;
    }

    declare class SmsModule extends ModuleBase_3 {
        /**
         * 获取短信功能全局配置
         * @example
         * ```js
         * const identifyCore = getIdentifyCore()
         * const smsConfig = identifyCore.sms.getSmsConfig()
         * console.log('短信图片验证码是否可用', smsConfig.smsImageCaptchaEnabled)
         * ```
         */
        getSmsConfig(): SmsConfig_2;
        /**
         * 生成图片验证码
         * @description 生成短信登录所需的图片验证码
         * @returns 图片验证码数据
         * @api
         */
        generateImageVerifyCode(): Promise<ImageVerifyCodeData_2>;
        /**
         * 发送短信验证码
         * @description 发送短信验证码到指定手机号
         * @param {SendSmsVerifyCodeParams} params 发送短信参数，包括手机号、场景等
         * @returns 发送结果
         * @api
         */
        sendSmsVerifyCode(params: SendSmsVerifyCodeParams_2): Promise<SendSmsVerifyResult_2>;
    }

    /**
     * 短信验证码场景
     */
    export declare enum SmsScene {
        /** 直播预约 */
        LiveBooking = "liveBooking",
        /** 观看条件：登记观看 */
        AuthInfo = "authInfo",
        /** 报名观看 */
        Enroll = "enroll",
        /** 手机号实名认证 */
        RealName = "realName",
        /** 一客一码 */
        SaleInvite = "saleInvite",
        /** 用户系统 */
        IdentityInfo = "identityInfo"
    }

    /**
     * 短信验证码场景
     */
    declare enum SmsScene_2 {
        /** 直播预约 */
        LiveBooking = "liveBooking",
        /** 观看条件：登记观看 */
        AuthInfo = "authInfo",
        /** 报名观看 */
        Enroll = "enroll",
        /** 手机号实名认证 */
        RealName = "realName",
        /** 一客一码 */
        SaleInvite = "saleInvite",
        /** 用户系统 */
        IdentityInfo = "identityInfo"
    }

    /**
     * 发送短信验证码的验证类型
     */
    export declare enum SmsValidType {
        /** 图片验证码 */
        Image = "image",
        /** 滑块验证码 */
        Slider = "slider",
        /** 无需验证码 */
        None = "none"
    }

    /**
     * 发送短信验证码的验证类型
     */
    declare enum SmsValidType_2 {
        /** 图片验证码 */
        Image = "image",
        /** 滑块验证码 */
        Slider = "slider",
        /** 无需验证码 */
        None = "none"
    }

    /**
     * 静默授权 watch 字段类型，0 - 使用静默授权，1 - 使用非静默授权
     */
    export declare type SnsApiBaseWatchType = 0 | 1;

    declare interface SocketCacheData<D = any> {
        event: string;
        data: D;
    }

    /**
     * @file
     *
     * Socket 监听消息类型(SocketTypes)，再从消息类型中去获取消息事件(SocketEvents)，其实应该是有嵌套的关系的，只是展平成枚举了
     */
    /**
     * Socket 消息事件
     */
    declare enum SocketEvents {
        /** 拒绝登录 */
        LoginRefuse = "LOGIN_REFUSE",
        /** 开始直播时传递的状态 */
        OnSliceStart = "onSliceStart",
        /** 初始化状态 */
        OnSliceId = "onSliceID",
        /** 研讨会-重新开始直播 */
        SeminarRestartLive = "restartLive",
        /** 研讨会-暂停直播 */
        SeminarStopLive = "stopLive",
        /** 聊天室令牌过期 */
        TokenExpired = "TOKEN_EXPIRED",
        /** 商品库事件 */
        ProductMessage = "PRODUCT_MESSAGE",
        /** 实时图文菜单更新事件 */
        ImageTextMenuChange = "IMAGE_TEXT_FOR_SHUNFENG",
        /** 发言 */
        Speak = "SPEAK",
        /** 点赞 */
        Likes = "LIKES",
        /** 情绪反馈，bubble */
        IsUnderstand = "isUnderstand",
        /** 登录 */
        Login = "LOGIN",
        /** 登出 */
        Logout = "LOGOUT",
        /** 当进入发起转播房间时被退出聊天室 */
        ExitWhenIsMain = "EXIT_WHEN_IS_MAIN",
        /** 设置昵称 */
        SetNick = "SET_NICK",
        /** 聊天室图片 */
        ChatImg = "CHAT_IMG",
        /** 学生提问 */
        StudentQuestion = "S_QUESTION",
        /** 老师回答 */
        TeacherAnswer = "T_ANSWER",
        /** 获取完整的消息，speak */
        GetFullMessage = "GET_FULL_MESSAGE",
        /** 风险测评-重置 */
        FinanceRiskEvaluationReset = "RESET",
        /** 商品库点击事件 */
        ProductClick = "PRODUCT_CLICK",
        /** 商品下单数量时间 */
        ProductBuyTimes = "PRODUCT_BUY_TIMES",
        /** 直播间观众签到次数 */
        SignInTimes = "SIGN_IN_TIMES",
        /** 讲师设置权限 */
        TeacherSetPermission = "TEACHER_SET_PERMISSION",
        /** 切换主副屏 */
        ChangeVideoAndPPTPosition = "changeVideoAndPPTPosition",
        /** 新增时间轴标记点 */
        AddTimeAxisMarkPoint = "ADD_DOT",
        /** 删除时间轴标记点 */
        DeleteTimeAxisMarkPoint = "DELETE_DOT",
        /** 编辑时间轴标记点 */
        EditTimeAxisMarkPoint = "EDIT_DOT",
        /** 实时字幕开启或关闭 */
        SubtitlesEnable = "ENABLE",
        /** 实时字幕 */
        SubtitlesRealCC = "ADD",
        /** 实时字幕翻译 */
        SubtitlesTranslate = "TRANSLATE",
        /** 更换双师模式 */
        ChangeDoubleMode = "changeDoubleMode",
        /**
         * 双师模式下，小房间开播中，切换到大房间后触发的小房间下课事件
         * @desc 在 ChangeDoubleMode 之后触发
         *  */
        FinishClass = "finishClass",
        /** 转播关联状态变更 */
        TransmitChannelSwitch = "SWITCH_TRANSMIT_CHANNEL",
        /** 课堂激励点赞 */
        MotivationLikes = "LIKES",
        /** 邀请活动结束 */
        InviteActivityOver = "OVER",
        /** 邀请活动更改结束时间 */
        InviteActivityChangeEndTimer = "CHANGE_TIMMER",
        /** 踢出用户 */
        RemoveUser = "REMOVE_USER",
        /** 评论上墙 */
        SpeakToTop = "TO_TOP",
        /** 取消评论上墙 */
        SpeakCancelTop = "CANCEL_TOP",
        /** 实时字幕翻译语言 */
        ListenLanguage = "LISTEN_LANGUAGE",
        /** 切换管理员发言公告 */
        ToggleGongGao = "TOGGLE_GONGGAO",
        /** 测试模式 */
        Debug = "DEBUG",
        /** 导播台推流尺寸变化 */
        GuideStreamVideoSizeChange = "videoSize"
    }

    /**
     * socket 的 message 事件处理集合
     */
    declare type SocketEventStoreHandlers = {
        [eventKey: EventKey]: EventHandler;
    };

    /**
     * socket 类型
     */
    declare type SocketEventType = 'message' | 'product' | 'lottery' | 'questionnaire' | 'coupon' | 'activityLottery' | 'testQuestion' | 'vote';

    /**
     * Socket 消息类型
     */
    declare enum SocketTypes {
        /** 气泡 */
        Bubble = "bubble",
        /** 表情 */
        Emotion = "emotion",
        /** 消息 */
        Message = "message",
        /** 发言 */
        Speak = "speak",
        /** 风险测评 */
        FinanceRiskEvaluation = "evaluation",
        /** 商品库 */
        Product = "product",
        /** 连麦请求 */
        JoinRequest = "joinRequest",
        /** 连麦相应 */
        JoinResponse = "joinResponse",
        /** 连麦离开 */
        JoinLeave = "joinLeave",
        /** 连麦成功 */
        JoinSuccess = "joinSuccess",
        /** 视频信息 */
        Video = "video",
        /** 视频信息 */
        Subtitles = "subtitles",
        /** 转播 */
        Transmit = "transmit",
        /**
         * 自定义消息
         * @desc 通过 socket 发送自定义消息才会有
         * */
        CustomMessage = "customMessage",
        /** 课堂激励 */
        Motivation = "motivation",
        /** 邀请 */
        Invite = "invite",
        /** 白名单 */
        WhiteList = "whiteList",
        /** 任务活动 */
        InteractEvent = "interactEvent",
        /** 提现 */
        Withdrawal = "withdrawal"
    }

    declare interface SourceInfo {
        /**
         * 来源类型
         * @default SourceType.Channel
         */
        sourceType?: SourceType;
        /**
         * 来源 id
         */
        sourceId?: string;
    }

    /**
     * 来源类型
     */
    declare enum SourceType {
        /** 聚合页 */
        AggregatePage = "AGGREGATE_PAGE",
        /** 信息流 */
        InfoFlow = "INFO_FLOW",
        /** 频道(直播间) */
        Channel = "CHANNEL"
    }

    /**
     * 特殊用户身份列表
     */
    export declare const SPECIAL_USER_TYPES: readonly [ChatUserType.Teacher, ChatUserType.Manager, ChatUserType.Guest, ChatUserType.Assistant, ChatUserType.Attendee, ChatUserType.Dummy];

    /**
     * 启动检查支付状态选项
     */
    export declare interface StartCheckAuthPayStatusTimerOptions {
        /**
         * 支付 id
         */
        payId?: string;
        /**
         * 支付成功回调
         */
        successCallback?: () => unknown;
        /**
         * 支付超时回调
         */
        timeoutCallback?: () => unknown;
    }

    /**
     * 启动检查微信支付状态选项
     */
    export declare interface StartCheckWechatPayStatusPollingOptions {
        /**
         * 订单 id
         */
        logId?: string;
        /**
         * 支付成功回调
         */
        successCallback?: () => unknown;
        /**
         * 支付超时回调
         */
        timeoutCallback?: () => unknown;
    }

    /**
     * 开始答题结果
     */
    declare type StartLotteryAnswerResult = CommonResult_2<LotteryFailReason, {
        /** 当前答题中的题目 id */
        questionId: string;
    }>;

    declare interface StatConfig extends StatParams {
        uid: string;
        channelId: string;
        origin?: string;
    }

    declare class StaticRequest extends PolyvRequest {
        constructor(iarCode: InteractionCore);
    }

    /**
     * 统计参数
     */
    export declare interface StatisticsParams {
        /**
         * 自定义统计参数 p4
         */
        param4?: string;
        /**
         * 自定义统计参数 p5
         */
        param5?: string;
    }

    declare interface StatParams {
        session_id?: string;
        param1?: string;
        param2?: string;
        param3?: string;
        param4?: string;
        param5?: string;
        key1?: string;
        key2?: string;
        key3?: string;
    }

    /** 暂停广告 */
    export declare type StopAdvertSetting = {
        /** 广告开关 */
        stopAdvertEnabled: YN;
        /** 广告图片 */
        stopAdvertImage: string;
        /** 广告链接 */
        stopAdvertHref: string;
        /** 广告链接类型 */
        stopHrefType: AdvertHrefType;
        /** 移动端链接 */
        stopMobileLink: string;
        /** PC端链接 */
        stopPcLink: string;
        /** PC跳转方式 */
        stopPcLinkJumpWay: LinkJumpWay;
        /** 微信小程序appId */
        stopWxMiniprogramAppId: string;
        /** 微信小程序链接 */
        stopWxMiniprogramLink: string;
        /** 微信小程序原始id */
        stopWxMiniprogramOriginalId: string;
        /** 跳转方式 */
        stopJumpWay: LinkJumpWay;
        /** 移动端app跳转链接 */
        stopMobileAppLink: string;
        /** 移动端 app 跳转方式 */
        stopMobileAppLinkJumpWay: LinkJumpWay;
        /** iOS 跳转链接 */
        stopIosLink: string;
        /** 安卓跳转链接 */
        stopAndroidLink: string;
        /** 鸿蒙跳转链接 */
        stopHarmonyLink: string;
    };

    /**
     * 流公共选项
     */
    export declare interface StreamCommonOptions {
        /**
         * 渲染节点
         */
        element: HTMLDivElement;
        /**
         * 控制栏
         * @default true
         */
        control?: boolean;
        /**
         * 视频裁剪模式
         * @default ConnectMicFitType.Cover
         */
        fit?: ConnectMicFitType;
    }

    /**
     * 流播放配置
     */
    declare interface StreamPlayOptions {
        /** 视频裁剪模式 */
        fit?: ConnectMicFitType;
    }

    /**
     * 推流属性类型
     */
    export declare type StreamProfile = '240p' | '240p_1' | '240p_4' | '480p' | '480p_1' | '480p_8' | '720p' | '720p_1' | '720p_2' | '720p_5' | '1080p_1' | '1080p_2';

    export declare interface StreamPushInfo {
        /** 是否导播台推流 */
        isNewGuide: YN;
        /** 分辨率宽度 */
        resolutionWidth: number;
        /** 分辨率高度 */
        resolutionHeight: number;
        /** 推流类型 */
        streamType: StreamType;
    }

    /**
     * @file 流相关的枚举
     */
    /**
     * 推流类型枚举
     */
    export declare enum StreamType {
        /** 音频推流 */
        Audio = "audio",
        /** 客户端推流 */
        Client = "client",
        /** 拉流直播 */
        Pull = "pull",
        /** 第三方拉流 */
        ThirdPull = "thirdpull",
        /** 硬盘拉流 */
        Disk = "disk"
    }

    declare interface SubmitAnswerData {
        questionId: string;
        answer: QuestionAnswerType | undefined;
        type: QuestionItemType;
    }

    /**
     * 提交答题参数
     */
    declare interface SubmitAnswerParams {
        /** 题目 id */
        questionId: string;
        /** 答案 */
        answer: QuestionAnswerType;
    }

    declare enum SubmitAnswerResult {
        /** 提交成功 */
        SubmitSuccess = "SubmitSuccess",
        /** 问卷已结束，提交被忽略 */
        QuestionnaireEnd = "QuestionnaireEnd",
        /** 已提交过答案 */
        AnswerSubmitted = "AnswerSubmitted",
        /** 提交失败 */
        SubmitFailed = "SubmitFailed"
    }

    /**
     * 提交答题结果
     */
    declare type SubmitAnswerResult_2 = CommonResult_2<LotteryFailReason, AnswerResultData>;

    /**
     * 自定义直播预约入参
     */
    export declare interface SubmitCustomLiveBookingOptions {
        /** 频道 id */
        otherChannelId?: string;
    }

    /**
     * 提交报名观看表单失败原因
     */
    export declare enum SubmitEnrollError {
        /** 未知错误 */
        Unknown = "Unknown",
        /** 缺少必填内容 */
        LackRequired = "LackRequired",
        /** 短信验证码错误 */
        SmsCodeVerifyError = "SmsCodeVerifyError"
    }

    /**
     * 提交报名观看表单参数
     */
    export declare interface SubmitEnrollFormParams {
        /** 验证手机号，authType 为 mobile 时必传 */
        phoneNumber?: string;
        /** 手机区号 */
        areaCode?: string;
        /** 短信验证码 */
        smsCode?: string;
        /** 验证邮箱，authType 为 email 时必传 */
        email?: string;
        /** 表单内容 */
        content: EnrollFormContent;
    }

    declare interface SubmitReceiveOptions {
        /**
         * 抽奖 id
         */
        lotteryId: string;
        /**
         * 兑换码
         */
        winnerCode: string;
        /**
         * 领取信息
         */
        receiveInfo: LotteryReceiveFormItem[];
    }

    export declare interface SubmitRewardReceiveIdOptions {
        /**
         * 活动 id
         */
        activityId: number;
        /**
         * 任务 id
         */
        taskId: number;
    }

    /**
     * 发送红包参数
     */
    export declare interface SubmitSendRedpackParams {
        /** 总金额，单位：元 */
        amount: number;
        /** 个数 */
        count: number;
        /** 祝福语 */
        greeting?: string;
    }

    /**
     * 发送红包结果
     */
    export declare type SubmitSendRedpackResult = CommonResult<SendRedpackFailReason, {
        /** 微信支付签名数据 */
        wxPaySignData: WxPaySignData;
    }>;

    /**
     * 短信预约直播入参
     */
    export declare interface SubmitSmsLiveBookingOptions {
        /** 手机号 */
        phoneNumber: string;
        /** 区号 */
        areaCode: string;
        /** 手机验证码 */
        verifyCode: string;
        /** 频道 id */
        otherChannelId?: string;
    }

    export declare interface SubmitTaskQuestionnaireOptions {
        taskId: number;
        questionnaireId: string;
        answer: PolyvQuestionnaire.SubmitAnswerData[];
    }

    export declare interface SubmitTaskQuestionnaireResult {
        /**
         * 答对题目数
         */
        correctAnswerCount: number;
        /**
         * 是否完成任务
         */
        reachCondition: boolean;
    }

    /**
     * 微信预约入参
     * @deprecated 请使用 WxLiveBookingOptions
     */
    export declare interface SubmitWxLiveBookingOptions {
        /** 频道 id */
        otherChannelId?: string;
    }

    /**
     * 订阅流选项
     */
    export declare interface SubscribeSteamOptions extends StreamCommonOptions {
        /**
         * 拉取视频流
         * @default true
         */
        video?: boolean;
        /**
         * 拉取音频流
         * @default true
         */
        audio?: boolean;
    }

    export declare interface SubtitleConfig {
        /** 实时字幕开关 */
        subtitleRealTimeEnabled: boolean;
        /** 实时字幕翻译开关 */
        subtitleTranslateEnabled: boolean;
        /** 实时原声语言 */
        subtitleSourceLanguage: SubtitleSourceLanguage;
        /** 实时字幕翻译后语言 */
        subtitleTranslateLanguage: SubtitleSourceTranslateLanguage;
        /**
         * 实时字幕翻译后语言（可选列表）
         * @version v1.7.0
         * */
        subtitleTranslateLanguages: SubtitleSourceTranslateLanguage[];
        /** 实时字幕显示数量限制开关  */
        subtitleDisplayNumberLimitEnabled: boolean;
        /** 实时字幕最多显示多少条 */
        subtitleDisplayNumber: number;
        /**
         * 本地观众是否打开实时字幕
         * @version v0.8.0
         */
        subtitleEnableByViewer: boolean;
        /**
         * 讲师是否允许打开实时字幕
         * @version v0.8.0
         */
        subtitleEnableByTeacher: boolean;
    }

    export declare interface SubtitleEnabled {
        /** 是否开启 */
        enable: boolean;
    }

    /** 实时字幕事件 */
    export declare enum SubtitleEvents {
        /** 实时字幕开关切换 */
        SubtitleEnableToggle = "SubtitleEnableToggle",
        /** 实时语音字幕 */
        SubtitleRealTimeCC = "SubtitleRealTimeCC",
        /** 实时语音翻译 */
        SubtitleTranslate = "SubtitleTranslate",
        /** 字幕列表重置 */
        SubtitleListReset = "SubtitleListReset",
        /**
         * 回放字幕对象改变
         * @version v0.9.0
         * @internal
         * @ignore
         * */
        SubtitleReplayTargetChanged = "SubtitleReplayTargetChanged",
        /**
         * 字幕列表数据强制同步
         * @version v1.7.0
         */
        SubtitleListForceSync = "SubtitleListForceSync",
        /**
         * 字幕配置更新
         * @version v2.0.0
         */
        SubtitleConfigUpdate = "SubtitleConfigUpdate"
    }

    export declare type SubtitleEventsRelations = {
        [SubtitleEvents.SubtitleEnableToggle]: SubtitleEnabled;
        [SubtitleEvents.SubtitleRealTimeCC]: SubtitleRealTimeCC;
        [SubtitleEvents.SubtitleTranslate]: SubtitleTranslate;
        [SubtitleEvents.SubtitleListReset]: void;
        [SubtitleEvents.SubtitleReplayTargetChanged]: void;
        [SubtitleEvents.SubtitleListForceSync]: {
            data: SubtitlesListItem[];
        };
        [SubtitleEvents.SubtitleConfigUpdate]: {
            config: SubtitleConfig;
        };
    };

    /**
     * 字幕行内容结构
     */
    export declare interface SubtitleParsedItem {
        start: number;
        end: number;
        text: string;
        index: string;
    }

    export declare interface SubtitleRealTimeCC {
        /** 下标 */
        index: number;
        /** 当前字幕 */
        text: string;
        /** 语言 */
        language: SubtitleSourceTranslateLanguage;
        /** 字幕类型 */
        sliceType: SubtitleSliceType;
    }

    export declare interface SubtitleSelectBtnConfig {
        index: number;
        show?: boolean;
        text?: string;
    }

    declare interface SubtitlesEnableMsgSocketType {
        EVENT?: SocketEvents.SubtitlesEnable;
        /** 是否开启 */
        enable: string;
        currentSubtitle?: {
            [lang in SubtitleSourceTranslateLanguage]: string;
        } & {
            /** 下标 */
            index: number;
            /** 相对时间 */
            relativeTime: number;
        };
    }

    export declare enum SubtitleSliceType {
        /** 一段话开始识别 */
        Start = 0,
        /** 一段话识别中,voice_text_str 为非稳态结果(该段识别结果还可能变化) */
        Processing = 1,
        /** 一段话识别结束,voice_text_str 为稳态结果(该段识别结果不再变化)  */
        End = 2
    }

    export declare type SubtitlesListItem = {
        [language in SubtitleSourceTranslateLanguage]?: string;
    } & {
        /** 下标 */
        index: number;
        /** 字幕类型 */
        sliceType?: SubtitleSliceType;
        /** 这句话的时长 */
        duration?: number;
        /** 相对开始直播的时间差 */
        relativeTime?: number;
    };

    /**
     * 原声字幕语言类型
     * */
    export declare type SubtitleSourceLanguage = BackstageSubtitleLanguage;

    /**
     * 翻译字幕语言类型
     * */
    export declare type SubtitleSourceTranslateLanguage = BackstageSubtitleLanguage;

    declare interface SubtitlesRealCCMsgSocketType {
        EVENT: SocketEvents.SubtitlesRealCC;
        /** 下标 */
        index: number;
        /** 字幕 */
        text: string;
        /** 相对时间 */
        relativeTime: number;
        /** 语言 */
        language: SubtitleSourceTranslateLanguage;
        /** 字幕类型 */
        sliceType: SubtitleSliceType;
        /** 替换的位 */
        replaceIndex: number;
    }

    declare interface SubtitlesTranslateMsgSocketType {
        EVENT: SocketEvents.SubtitlesTranslate;
        /** 下标 */
        index: number;
        /** 翻译结果 */
        result: string;
        /** 语言 */
        language: SubtitleSourceTranslateLanguage;
    }

    export declare interface SubtitleTranslate {
        /** 下标 */
        index: number;
        /** 翻译结果 */
        result: string;
        /** 语言 */
        language: string;
        /** 这句话的时长,可以用setTimeout控制显示时长 */
        duration?: number;
    }

    /**
     * 字幕翻译选项列表
     */
    export declare type SubtitleTranslateOption = CommonOption<SubtitleSourceTranslateLanguage | string>;

    /**
     * 支持结果
     */
    export declare interface SupportResult {
        /** 是否支持 */
        support: boolean;
    }

    /**
     * 支持结果
     */
    declare interface SupportResult_2 {
        /** 是否支持 */
        support: boolean;
    }

    declare type TabletLayoutSetting = 'follow_pc' | 'follow_mobile';

    /**
     * 任务活动配置
     */
    export declare interface TaskActivityConfig {
        /**
         * 外部积分单位
         */
        externalPointUnit: string;
    }

    /**
     * 任务活动配置
     */
    export declare interface TaskActivityData {
        /**
         * 频道号
         */
        channelId: number;
        /**
         * 活动 id
         */
        activityId: number;
        /**
         * 活动名称
         */
        activityName: number;
        /**
         * 任务规则
         */
        taskRule: TaskActivityRule;
        /**
         * 任务列表
         */
        tasks: TaskActivityItem[];
    }

    /**
     * 任务活动模块事件
     */
    export declare enum TaskActivityEvents {
        /**
         * 任务开始
         * @description 管理后台设置的任务到达开始时间后回调该事件
         */
        StartTask = "StartTask",
        /**
         * 任务结束
         * @description 管理后台设置的任务到达结束时间或手动结束后回调该事件
         */
        EndTask = "EndTask",
        /**
         * 任务活动数据更新
         */
        TaskActivityDataUpdate = "TaskActivityDataUpdate",
        /**
         * 获得奖励
         */
        ObtainReward = "ObtainReward",
        /**
         * 获取基础数据失败
         */
        GetBaseDataError = "GetBaseDataError"
    }

    export declare type TaskActivityEventsRelations = {
        [TaskActivityEvents.StartTask]: {
            /**
             * 任务活动 id
             */
            activityId: number;
        };
        [TaskActivityEvents.EndTask]: {
            /**
             * 任务活动 id
             */
            activityId: number;
        };
        [TaskActivityEvents.TaskActivityDataUpdate]: {
            activityData: TaskActivityData;
        };
        [TaskActivityEvents.ObtainReward]: {
            /**
             * 任务完成数据
             */
            finishData: TaskActivityFinishData;
        };
        [TaskActivityEvents.GetBaseDataError]: {
            /**
             * 任务活动 id
             */
            activityId: number;
        };
    };

    /**
     * 任务完成数据
     */
    export declare interface TaskActivityFinishData {
        /**
         * 活动 id
         */
        activityId: number;
        /**
         * 任务 id
         */
        taskId: number;
        /**
         * 领取信息
         */
        acceptInfo?: TaskRewardAcceptInfo;
        /**
         * 任务奖励
         */
        taskReward: TaskActivityRewardSetting;
    }

    /**
     * 任务活动初始化配置
     */
    export declare interface TaskActivityInitConfigOptions {
        /**
         * 是否允许启动任务活动
         */
        taskActivityEnabled?: boolean;
    }

    /**
     * 任务节点
     */
    export declare interface TaskActivityItem {
        /**
         * 任务 id
         */
        taskId: number;
        /**
         * 任务开始时间
         */
        startTime: number;
        /**
         * 任务结束时间
         */
        endTime: number;
        /**
         * 任务完成时间
         */
        finishTime?: number;
        /**
         * 领取信息
         */
        acceptSetting?: TaskRewardAcceptInfo;
        /**
         * 达成条件
         */
        reachCondition: TaskActivityReachCondition;
        /**
         * 奖励设置
         */
        rewardSetting: TaskActivityRewardSetting;
        /**
         * 任务状态
         */
        status: TaskActivityStatus;
        /**
         * 是否达成
         */
        isReach: boolean;
        /**
         * 奖励状态
         */
        rewardStatus?: TaskRewardStatus;
        /**
         * 发放失败原因
         */
        outTradeErrCode?: OutTradeErrorCode | null;
        /**
         * 参与条件
         */
        participationCondition?: TaskActivityParticipationCondition;
    }

    export declare interface TaskActivityParticipationCondition {
        /**
         * 参与类型
         */
        type: 'all' | 'userLabel';
        /**
         * 参与的用户标签 id
         */
        userLabels: number[];
    }

    /**
     * 任务达成条件
     */
    export declare interface TaskActivityReachCondition {
        /**
         * 达成条件类型
         */
        type: TaskActivityType;
        /**
         * 问卷 id
         */
        questionnaireId?: string;
        /**
         * 当前进度，在线时长时单位为：毫秒
         */
        currentSchedule?: number;
        /**
         * 数量，在线时长时单位为：分钟
         */
        amount: number;
        /**
         * 自定义图标
         */
        customIcon?: string;
        /**
         * 自定义事件
         */
        customEvent?: string;
        /**
         * 自定义名称
         */
        customEventName?: string;
        /**
         * 自定义单位
         */
        customUnit?: string;
        /**
         * 自定义达成文本模板
         */
        customReachText?: string;
        /**
         * 自定义按钮文本
         */
        customButtonText?: string;
    }

    /**
     * 任务奖励设置
     */
    export declare interface TaskActivityRewardSetting {
        /**
         * 任务奖励类型
         */
        type: TaskActivityRewardType;
        /**
         * 总数量
         */
        amount: number;
        /**
         * 自定义奖励的内容
         */
        customReward: string;
    }

    /**
     * 任务奖励类型
     */
    export declare enum TaskActivityRewardType {
        /**
         * 现金
         */
        Cash = "cash",
        /**
         * 自定义
         */
        Custom = "custom",
        /**
         * 无奖励
         */
        Nothing = "nothing",
        /**
         * 积分
         */
        Point = "point",
        /**
         * 外部积分
         */
        ExternalPoint = "externalPoint"
    }

    /**
     * 任务规则
     */
    export declare enum TaskActivityRule {
        /**
         * 解锁任务
         */
        UnlockTask = 1,
        /**
         * 并行任务
         */
        ParallelTask = 2
    }

    export declare enum TaskActivityStatus {
        /**
         * 未开始
         */
        NotStart = "notStart",
        /**
         * 进行中
         */
        InProgress = "inProgress",
        /**
         * 已完成
         */
        Finish = "finish"
    }

    /**
     * 任务达成条件类型
     */
    export declare enum TaskActivityType {
        /**
         * 签到
         */
        Sign = "sign",
        /**
         * 在线时长
         */
        Online = "online",
        /**
         * 答题问卷
         */
        Questionnaire = "questionnaire",
        /**
         * 自定义
         */
        Custom = "custom"
    }

    export declare interface TaskRewardAcceptInfo {
        /**
         * 是否主动领奖
         */
        activeAcceptEnabled: YN;
        /**
         * 领取方式
         */
        acceptType: RewardAcceptType;
        /**
         * 表单列表
         */
        formInfo: RewardAcceptFormItem[];
        /**
         * 奖品地址
         */
        prizeUrl: string | null;
        /**
         * 二维码地址
         */
        qrCode: string | null;
        /**
         * 二维码提示
         */
        qrCodeTips: string | null;
        /**
         * 是否已领取
         */
        received: YN;
    }

    /**
     * 任务奖励类型
     */
    export declare interface TaskRewardItem {
        /**
         * 记录 id
         */
        id: number;
        /**
         * 奖励状态
         */
        rewardStatus: TaskRewardStatus;
        /**
         * 任务 id
         */
        taskId: number;
        /**
         * 任务条件
         */
        taskReach: TaskActivityReachCondition;
        /**
         * 任务奖励
         */
        taskReward: TaskActivityRewardSetting;
        /**
         * 任务完成时间
         */
        finishTime: number;
        /**
         * 奖励发放失败原因
         */
        outTradeErrCode?: OutTradeErrorCode | null;
        /**
         * 如果是企业营销账户异常，则返回微信的错误码
         */
        outTradeErrDesc?: string;
        /**
         * 领取信息
         */
        acceptInfo?: TaskRewardAcceptInfo;
    }

    /**
     * 任务奖励发放状态
     */
    export declare enum TaskRewardStatus {
        /**
         * 待发放
         */
        NotIssued = 0,
        /**
         * 已发放
         */
        Issued = 1,
        /**
         * 名额已满
         */
        IssuedLimit = 2,
        /**
         * 发放失败
         */
        IssuedFail = 3,
        /**
         * 发放中
         */
        Issueding = 4,
        /**
         * 无需发放
         */
        NotNeedIssued = -1
    }

    /**
     * 讲师信息类型
     */
    export declare type TeacherInfoType = ChatMessageUser<ChatUserType.Teacher> & {
        /** 是否关联主讲 */
        anchorEnabled: boolean;
        /**
         * 主讲 id
         */
        anchorId?: number;
    };

    export declare interface TimeAxisMarkBaseInfo {
        /** 打点信息Id */
        id: string;
        /** 用户Id */
        userId?: string;
        /** 频道Id */
        channelId?: number;
        /** 视频Id */
        videoId?: null;
        /** 文件Id */
        fileId?: string;
        /** 打点标记类型 */
        markType: number;
        /** 打点标记时间 */
        markTime: string | number;
        /** 打点标记信息 */
        markMessage: TimeAxisMarkMessage;
    }

    /**
     * 时间轴标记(打点)模块事件
     * @eventenum {@link TimeAxisPointEventsRelations}
     */
    export declare enum TimeAxisMarkEvents {
        /**
         * 打点信息修改事件
         * @internal
         * @ignore
         */
        TimeAxisMarkListChange = "TimeAxisMarkListChange"
    }

    /** 打点信息-解析后的数据 */
    export declare interface TimeAxisMarkInfo extends TimeAxisMarkBaseInfo {
        /** 打点标记时间 */
        markTime: number;
        /** 打点相对百分比，浮点数 */
        percents: number;
    }

    /** 打点标记信息预览 */
    export declare interface TimeAxisMarkMessage {
        /** 打点标记信息-预览图链接 */
        previewUrl: string;
        /** 打点标记信息-标题 */
        title: string;
    }

    /** 打点信息-源数据 */
    export declare interface TimeAxisMarkOriginInfo extends TimeAxisMarkBaseInfo {
        /** 用户Id */
        userId: string;
        /** 频道Id */
        channelId: number;
        /** 视频Id */
        videoId: null;
        /** 文件Id */
        fileId: string;
        /** 打点标记时间 */
        markTime: string;
    }

    /** 打点请求参数 */
    export declare interface TimeAxisMarkQueryParam {
        /** 场次Id */
        sessionId: string;
        /** 推流开始时间，时间戳 */
        pushStreamStartTime: number;
        /** 视频文件Id */
        fileId?: string;
        /** 视频Id */
        videoId?: string;
    }

    /**
     * 时间轴标记(打点)模块事件回调参数配置
     */
    export declare type TimeAxisPointEventsRelations = {
        [TimeAxisMarkEvents.TimeAxisMarkListChange]: {
            /** 打点列表 */
            timeAxisMarkList: TimeAxisMarkInfo[];
        };
    };

    /**
     * 直播时移服务
     * @version v0.5.0
     */
    declare class TimeShiftService {
        protected _playerModule: PlvPlayerModule;
        constructor(_playerModule: PlvPlayerModule);
        private __timeShiftData;
        private __getServerTimeShiftData;
        private __getTimeShiftStreamInfo;
        setTimeShiftData(): void;
        getTimeShiftData(): PlayerTimeShiftData | undefined;
        /**
         * 是否支持时移功能
         */
        getSupportTimeShift(): boolean;
        destroy(): void;
    }

    declare interface TimeShiftStreamInfo {
        /** 服务端-当前播放时间 */
        serverCurrentTime: number;
        /** 服务端-推流开始时间 */
        serverPushStreamStartTime: number;
        /** 本地-当前播放时间 */
        localCurrentTime: number;
        /** 本地-推流开始时间 */
        localPushStreamStartTime: number;
        /** 推流间隔，单位：秒 */
        duration: number;
        /** 场次Id，在时移功能中仅用来判断是否为不同场次 */
        sessionId?: string;
    }

    declare interface TrackEventData {
        /** 事件名 */
        event_id: string;
        /** 事件类型 */
        event_type: string;
        /** 事件属性，不能为空对象 */
        spec_attrs: Record<string, unknown>;
    }

    export declare interface TrackEventOptions {
        /** 事件类型 */
        eventType: RtasTrackEventType;
        /** 事件 id */
        eventId: RtasTrackEventId;
        /** 事件数据，必须指定且不能为空对象 */
        data: UniversalParams<string>;
    }

    /**
     * @level
     * 0：质量未知
     * 1：质量极好
     * 2：用户主观感觉和极好差不多，但码率可能略低于极好
     * 3：用户主观感受有瑕疵但不影响沟通
     * 4：勉强能沟通但不顺畅
     * 5：网络质量非常差，基本不能沟通
     * 6：网络连接断开，完全无法沟通
     */
    /**
     * 上行网络质量级别
     */
    export declare type UplinkNetworkQuality = 0 | 1 | 2 | 3 | 4 | 5 | 6;

    declare interface UploadImageOptions {
        /**
         * 文件对象
         */
        file: File;
        /**
         * 类型
         */
        type?: string;
    }

    export declare interface UploadImageResult {
        /** 图片 id */
        imageId: string;
        /** 图片地址 */
        imageUrl: string;
        /** 图片尺寸 */
        size: ChatImage['size'];
    }

    /**
     * 多图片上传失败结果
     */
    export declare interface UploadMultiImageFailResult {
        /** 图片id */
        imageId: string;
        /** 图片预览url */
        previewSrc: string;
    }

    /**
     * 多图片上传准备结果（已完成图片选择）
     */
    export declare interface UploadMultiImageReadyResult {
        /** 图片id */
        imageId: string;
        /** 图片预览url */
        previewSrc: string;
    }

    /**
     * 多图片上传完成结果
     */
    export declare type UploadMultiImageSuccessResult = UploadImageResult;

    declare type UserAgreementConfig = {
        [key in LangType_2]: {
            /** 内容 */
            content: string;
            /** 弹窗标题 */
            dialogTitle: string;
            /** 弹窗内容 */
            dialogContent: string;
        };
    };

    /**
     * 用户模块事件
     * @eventenum {@link UserEventsRelations}
     */
    export declare enum UserEvents {
        /**
         * 用户信息更改
         * @description 用户信息更改时触发该事件。
         * @example
         * ```js
         * watchCore.user.eventEmitter.on(UserEvents.UserInfoChange, (data) => {
         *   console.log('新的用户信息', data.userInfo);
         * });
         * ```
         */
        UserInfoChange = "UserInfoChange",
        /**
         * 任意用户设置昵称
         * @description 任意用户设置昵称后触发该事件。
         * @example
         * ```js
         * watchCore.user.eventEmitter.on(UserEvents.UserSetNick, (data) => {
         *   console.log('该用户的 userId', data.userId);
         *   console.log('该用户的新昵称', data.nickname);
         * });
         * ```
         */
        UserSetNick = "UserSetNick",
        /**
         * 当前用户设置昵称
         * @description 调用 `user.updateUserNick` 修改昵称成功后触发该事件。
         * @example
         * ```js
         * watchCore.user.eventEmitter.on(UserEvents.CurrentUserSetNick, () => {
         *   toast.success('修改昵称成功');
         * });
         * ```
         */
        CurrentUserSetNick = "CurrentUserSetNick",
        /**
         * 设置昵称失败
         * @description 调用 `user.updateUserNick` 修改昵称失败后触发该事件。
         * @example
         * ```js
         * watchCore.user.eventEmitter.on(UserEvents.SetNickError, (data) => {
         *   toast.error('修改昵称失败：' + data.message);
         * });
         * ```
         */
        SetNickError = "SetNickError",
        /**
         * 当前用户被踢出聊天室
         * @version v0.6.0
         * @description 当管理员或助教踢出当前用户时触发该事件。
         * @example
         * ```js
         * watchCore.user.eventEmitter.on(UserEvents.CurrentUserKicked, () => {
         *   toast.error('你已被踢出');
         *   // TODO：重定向到踢出页
         * });
         * ```
         */
        CurrentUserKicked = "CurrentUserKicked"
    }

    /**
     * 用户模块事件回调参数配置
     */
    export declare type UserEventsRelations = {
        [UserEvents.UserInfoChange]: {
            /**
             * 新的用户信息
             */
            userInfo: UserInfoDetail;
        };
        [UserEvents.UserSetNick]: {
            /**
             * 用户 userId
             */
            userId: string;
            /**
             * 新的昵称
             */
            nickname: string;
        };
        [UserEvents.CurrentUserSetNick]: {
            /**
             * 用户 userId
             */
            userId: string;
            /**
             * 新的昵称
             */
            nickname: string;
        };
        [UserEvents.SetNickError]: {
            /**
             * 失败信息
             */
            message: string;
        };
    };

    /**
     * 观众基本信息
     */
    export declare interface UserInfo {
        /**
         * 用户 id
         */
        userId?: string;
        /**
         * 观众昵称
         */
        nick?: string;
        /**
         * 观众头像
         */
        pic?: string;
        /**
         * 观众头衔
         * @version v0.11.0
         */
        actor?: string;
    }

    /**
     * 用户信息
     */
    declare interface UserInfo_2 {
        /**
         * 用户 id
         */
        userId: string;
        /**
         * 唯一 id
         */
        unionId?: string;
        /**
         * 用户昵称
         */
        nick: string;
        /**
         * 用户头像
         */
        pic: string;
        /**
         * 用户类型
         */
        userType?: string;
        /**
         * 用户登录方式
         */
        authType?: string;
        /**
         * 微信 unionId
         */
        wxUnionId?: string;
        /**
         * 微信 openId
         */
        wxOpenId?: string;
    }

    /**
     * 用户信息
     */
    declare interface UserInfo_3 {
        /**
         * 用户 id
         */
        userId: string;
        /**
         * 用户昵称
         */
        nick: string;
        /**
         * 用户头像
         */
        pic: string;
    }

    /**
     * 观众详细信息
     */
    export declare interface UserInfoDetail extends UserInfo {
        /**
         * 微信 openid
         */
        openId?: string;
        /**
         * 微信 unionId
         */
        unionId?: string;
        /**
         * 该用户的授权方式
         */
        authType?: AuthType;
        /**
         * 跑马灯名称
         * @internal
         * @ignore
         */
        marqueeName?: string;
        /**
         * 标签
         * @version v1.2.0
         */
        label?: {
            /** 提问区标签 */
            question: string[];
        };
    }

    export declare interface UserListResult {
        /**
         * 在线人数
         */
        count: number;
        /**
         * 列表
         */
        userlist: ChatMessageUser[];
    }

    /**
     * 用户登录配置
     */
    declare interface UserLoginBasicConfig {
        /** 公司名称 */
        companyName: string;
        /** 公司 logo */
        companyLogo: string;
        /** 用户协议 url 地址 */
        agreement: string;
        /** 是否支持微信授权 */
        weixinAuthEnabled: boolean;
        /** 开发非强制绑定手机号 */
        collectMobileEnabled: boolean;
        /** 登录注册类型限制 {@link RegisterLoginType} */
        registerLoginType: string;
        /** 游客模式开关 */
        guestModeEnabled: boolean;
        /** 游客外链登录配置 */
        guestLinkLoginConfig: Partial<LinkData> | null;
        /** 账号短信功能是否可用 */
        smsEnabled: boolean;
    }

    /**
     * 用户登录配置
     */
    declare interface UserLoginConfig extends UserLoginBasicConfig {
        /** 用户协议配置 */
        agreementConfig: UserAgreementConfig;
    }

    declare interface UserLoginScanConfig {
        /** 二维码链接 */
        qrCodeUrl: string;
        /** 场景Id */
        sceneId: string;
    }

    declare enum UserLoginScanStatus {
        /** 初始状态 */
        Init = "INIT",
        /** 已扫码 */
        Scanned = "SCANED",
        /** 已取消 */
        Canceled = "CANCELED",
        /** 已过期 */
        Expired = "EXPIRED",
        /** 成功 */
        Success = "SUCCESS",
        /** 失败 */
        Fail = "FAIL"
    }

    declare interface UserStream {
        getAudioLevel(): string | number | undefined;
        resume: () => void;
    }

    /**
     * 用户流对象
     */
    declare interface UserStreamInstance extends MicStreamInfo {
        /** 是否讲师 */
        teacher: boolean;
        /** 是否第一画面 */
        master: boolean;
        /** 流 */
        stream?: UserStream;
        /** 订阅流 */
        subscribe(options: UserStreamSubscribeOptions): void;
    }

    declare interface UserStreamSubscribeOptions extends RtcStreamCommonOptions {
        /** 拉取视频流，默认：true */
        video?: boolean;
        /** 拉取音频流，默认：true */
        audio?: boolean;
    }

    /**
     * 用户提现统计数据
     */
    export declare interface UserWithdrawStatistics {
        /** 账户未提现余额 */
        totalAmount: number;
        /** 抢到的红包总额 */
        totalReceive: number;
        /** 已完成的提现总金额 */
        totalWithdraw: number;
        /** 提现中的金额 */
        totalWithdrawing: number;
    }

    /**
     * 工具模块
     * @class
     */
    declare class UtilsModule extends ModuleBase_3 {
        /**
         * 生成用于重定向的二维码地址
         * @description 将指定URL生成为短链二维码地址
         * @param {string} url 二维码内容URL
         * @returns 二维码地址
         * @api
         */
        generateQrcodeUrl(url: string): string;
    }

    declare interface VEPublicSrteam {
        publicStreamId: string;
        video: HTMLVideoElement;
        audio: HTMLAudioElement;
        resume(): Promise<void>;
        pause(): Promise<void>;
        stop(): Promise<void>;
        /** 音量设定[0,1] */
        setVolume(val: number): void;
        getPaused(): boolean;
        on(evtName: string, fun: () => void): void;
        emit(evtName: string): void;
    }

    /**
     * 验证验证码观看参数
     */
    export declare interface VerifyCodeAuthParams {
        /**
         * 验证码
         */
        code: string;
        /**
         * 图片 id
         */
        imageId: string;
        /**
         * 图片验证码
         */
        captcha: string;
    }

    export declare namespace VerifyCodeAuthRequest {
        export interface RequestData {
            /** 验证码 */
            code: string;
            /** 图片验证码 */
            captcha?: string;
            /** 图片 id */
            imageId?: string;
        }
    }

    /**
     * 验证验证码观看结果
     */
    export declare type VerifyCodeAuthResult = AuthVerifyResult<AuthType.Code>;

    export declare namespace VerifyCustomAuthRequest {
        export interface RequestData extends UniversalParams<string> {
            token: string;
        }
    }

    /**
     * 验证自定义授权签名参数结果
     */
    export declare type VerifyCustomAuthResult = AuthVerifyResult<AuthType.Custom>;

    /**
     * 验证独立授权签名结果
     */
    export declare type VerifyDirectAuthResult = AuthVerifyResult<AuthType.Direct>;

    /**
     * 验证外部授权签名参数结果
     */
    export declare type VerifyExternalAuthResult = AuthVerifyResult<AuthType.External>;

    /**
     * 验证登记观看参数
     */
    export declare interface VerifyInfoAuthParam {
        /**
         * 手机号
         */
        phoneNumber?: string;
        /**
         * 手机区号
         */
        areaCode?: string;
        /**
         * 短信验证码
         */
        smsCode?: string;
        /**
         * 登记填写信息
         */
        formValues: string[];
    }

    export declare namespace VerifyInfoAuthRequest {
        export interface RequestData extends AuthInfoPropValType {
            /** 手机号，带区号格式 */
            mobile?: string;
            /** 短信验证码 */
            smsCode?: string;
        }
    }

    /**
     * 验证登记观看结果
     */
    export declare type VerifyInfoAuthResult = AuthVerifyResult<AuthType.Info>;

    /**
     * 验证邀请观看授权参数
     */
    export declare interface VerifyInviteWatchAuthParams {
        /** 分销员 Id */
        saleId: string;
    }

    export declare type VerifyInviteWatchAuthResult = CommonResult<VerifyInviteWatchFailReason, {
        /** 是否需要审核 */
        needAudit: boolean;
    }>;

    export declare enum VerifyInviteWatchFailReason {
        /** 未知错误 */
        Unknown = "Unknown",
        /** 销售Id错误 */
        SaleIdError = "SaleIdError"
    }

    /**
     * 登录 token 验证验证失败原因
     */
    export declare enum VerifyLoginTokenFail {
        /**
         * 无效 token
         */
        TokenInvalid = "TokenInvalid"
    }

    /**
     * 验证结果
     */
    export declare type VerifyLoginTokenResult = CommonResult<VerifyLoginTokenFail>;

    /**
     * 验证无条件观看/公开观看结果
     */
    export declare type VerifyNoneAuthResult = AuthVerifyResult<AuthType.None>;

    /**
     * 验证白名单观看参数
     */
    export declare type VerifyPhoneAuthParams = {
        /**
         * 会员码信息（与 phoneAuthToken 二选一）
         */
        phone: string;
        /**
         * 白名单 token（与 phone 二选一）
         */
        phoneAuthToken?: never;
        /**
         * 浏览器访客 id
         */
        visitorId?: string;
    } | {
        /**
         * 白名单 token（与 phone 二选一）
         */
        phoneAuthToken: string;
        /**
         * 会员码信息（与 phoneAuthToken 二选一）
         */
        phone?: never;
        /**
         * 浏览器访客 id
         */
        visitorId?: string;
    };

    export declare namespace VerifyPhoneAuthRequest {
        export interface RequestData {
            /** 会员码（与 phoneAuthToken 二选一） */
            phone?: string;
            /** 白名单 token（与 phone 二选一） */
            phoneAuthToken?: string;
            /** 浏览器指纹 */
            fingerprint?: string;
        }
    }

    /**
     * 验证白名单观看结果
     */
    export declare type VerifyPhoneAuthResult = AuthVerifyResult<AuthType.Phone>;

    export declare enum VerifySaleInviteAuthFailReason {
        /** 未知错误 */
        Unknown = "Unknown",
        /** 销售码错误 */
        SaleCodeError = "SaleCodeError"
    }

    export declare interface VerifySaleInviteAuthParams {
        /**
         * 手机号
         */
        phoneNumber?: string;
        /**
         * 手机区号
         */
        areaCode?: string;
        /**
         * 短信验证码
         */
        smsCode?: string;
        /**
         * 联系人名称
         */
        username?: string;
        /**
         * 地址
         */
        address?: string;
        /**
         * 企业名称
         */
        corpName?: string;
        /**
         * 职务
         */
        position?: string;
        /**
         * 邮箱
         */
        email?: string;
    }

    /** 唯一性登录验证失败原因 */
    export declare enum VerifyViewerSessionFail {
        /** 未知 */
        Unknow = "Unknow",
        /** 异地登录 */
        RemoteLogin = "RemoteLogin"
    }

    export declare type VerifyViewerSessionResult = CommonResult<VerifyViewerSessionFail, {
        /** 轮训频率 */
        channelVerifyQueryFrequency: number;
    }>;

    export declare interface VideoSize {
        width: number;
        height: number;
    }

    /**
     * 观众作答结果
     */
    declare interface ViewerAnswerResult {
        /** 问卷 id */
        questionnaireId: string;
        /** 观众作答结果 */
        resultData: Record<string, ViewerAnswerResultData>;
        /** 作答答案 */
        answers: Record<string, QuestionAnswerType>;
    }

    /** 题目作答情况 */
    declare interface ViewerAnswerResultData {
        /** 问题 id */
        questionId: string;
        /** 问题正确答案 */
        rightAnswer: QuestionAnswerType | undefined;
        /** 题目作答 */
        answer: QuestionAnswerType | undefined;
        /** 是否回答正确 */
        isRight: boolean;
    }

    export declare interface ViewerChannelPromotion {
        /**
         * 邀请榜列表设置
         */
        inviteListSetting: InviteListSetting | null;
    }

    /**
     * 观众详情
     */
    declare interface ViewerDetail {
        viewerUnionInfo: ViewerUnionInfo;
        wxInfo: WxInfo_2;
    }

    /**
     * 观众信息（后端）
     */
    export declare interface ViewerInfo {
        /** 观众 id */
        viewerId: string;
        /** 观众昵称 */
        nickname: string;
        /** 观众头像 */
        avatar: string | null;
        /** 跑马灯名称 */
        marqueeName: string | null;
        /** 微信 openid */
        openid: string | null;
        /** 微信 unionId */
        unionId: string | null;
        /** 授权方式 */
        authType: AuthType;
        /** 统计参数4 */
        param4: string | null;
        /** 统计参数5 */
        param5: string | null;
        /** 特殊的测试模式观众，该观众身份下非测试模式（可以看直播） */
        param6: 'testModeViewer' | null;
        /** 报名观看是否使用姓名作为昵称 */
        enrollNickEnabled: YN | null;
        /** 头衔 */
        actor: string | null;
        /** 跟进人 id */
        saleId?: string | null;
    }

    declare interface ViewerLabelItem {
        /**
         * 标签 id
         */
        id: number;
        /**
         * 标签名称
         */
        label: string;
    }

    /**
     * 用户跟进人信息
     */
    export declare interface ViewerSaleInfo {
        /** 跟进人 id */
        saleId: string | undefined;
    }

    export declare interface ViewerSeatInfo {
        /** 介绍 */
        intro: string | null;
        /** 职级 */
        position: string | null;
        /** 座位号 */
        seatNumber: number;
        /** 云席类型: vip vip嘉宾  viewer 普通嘉宾 */
        type: ViewerSeatType;
        /** 是否为 vip 嘉宾 */
        isVip: boolean;
    }

    export declare type ViewerSeatType = 'viewer' | 'vip';

    /**
     * 用户令牌数据
     */
    declare interface ViewerTokenData {
        viewerToken: string;
    }

    /**
     * 用户令牌数据
     */
    declare interface ViewerTokenData_2 {
        viewerToken: string;
    }

    export declare interface ViewerUnionInfo {
        /** 唯一 id */
        viewerUnionId: string;
        /** 微信昵称 */
        wxNickName: string;
        /** 微信头像 */
        wxAvatar: string;
        /** 微信 openId */
        wxOpenId: string;
        /** 微信 unionId */
        wxUnionId: string;
        /** 昵称 */
        nickname: string;
        /** 手机号 */
        mobile: string;
        /** 最新的认证时间 */
        latestAuthTime: number;
        /** 额外数据 */
        ext: ViewerUnionInfoEXT;
        /** 外部用户 Id */
        externalViewerId: string | null;
        /** 用户标签列表 */
        labels?: ViewerUnionLabelItem[];
        /** 用户状态 */
        status: ViewerUnionStatus;
    }

    declare interface ViewerUnionInfoEXT {
        ip: string;
        device: string;
        name: null;
        mobile: null;
        email: null;
        area: null;
        /** 是否邀请员 */
        inviteSales: YN_2;
        /** 是否邀请员管理员 */
        inviteSalesAdmin: YN_2;
        /** 邀请员所属 ID */
        organizationId: number;
    }

    declare interface ViewerUnionLabelItem {
        id: number;
        label: string;
    }

    declare enum ViewerUnionStatus {
        NORMAL = "NORMAL",
        GUEST = "GUEST"
    }

    /**
     * @file 请求相关的类型定义
     */
    /** 点播相关域名 */
    declare interface VodDomainInfo {
        /**
         * 点播图片静态资源域名
         * @internal
         * @ignore
         * @default https://img.videocc.net
         */
        vodImgStatic: string;
        /**
         * 点播视频静态资源域名
         * @internal
         * @ignore
         * @default https://static.polyv.net
         */
        vodStaticDomain: string;
        /**
         * 点播授权验证域名
         * @internal
         * @ignore
         * @default https://v3.polyv.net
         */
        vodAuthDomain: string;
        /**
         * 点播加密域名
         * @internal
         * @ignore
         * @default https://v.polyv.net
         */
        vodEncryptDomain: string;
        /**
         * 点播测试域名
         * @internal
         * @ignore
         * @default https://beta.polyv.net
         */
        vodBetaDomain: string;
        /**
         * 点播 hls 域名
         * @internal
         * @ignore
         * @default https://hls.videocc.net
         */
        vodHlsDomain: string;
        /**
         * 点播 rtas 采集域名
         * @internal
         * @ignore
         * @default https://prtas.videocc.net
         */
        vodRtasDomain: string;
        /**
         * 点播 rtas 采集域名-备份
         * @internal
         * @ignore
         * @default https://prtas-2.videocc.net
         */
        vodRtasDomain2: string;
        /**
         * 点播播放器短点续播域名
         * @internal
         * @ignore
         * @default https://script.polyv.net
         */
        vodScriptDomain: string;
    }

    /**
     * 点播播放器授权参数
     */
    declare interface VodPlayerAuthOptions {
        /** 授权验证设置自定义的code */
        code?: string;
    }

    declare interface VodPlayerBarrageOptions {
        /** 开启弹幕（mobile），默认：false */
        openDanMu?: boolean;
        /** 弹幕默认是否开启（mobile），默认：off */
        isBarrage?: 'on' | 'off';
    }

    /**
     * 点播播放器基础参数
     */
    declare interface VodPlayerBasicOptions {
        wrap: string | HTMLDivElement;
        /** 宽度 */
        width?: string;
        /** 高度 */
        height?: string;
        /** 自动播放 */
        autoplay?: boolean;
        /** 引用默认键盘事件，默认：false */
        preventKeyboardEvent?: boolean;
        domainInfo?: VodPlayerDomainInfoOptions;
        speed?: false | number[];
        /** 是否使用网页全屏（mobile），默认：false */
        webPageFullScreen?: boolean;
        /** 网页全屏下的层叠数（mobile） */
        fullscreenZIndex?: number;
        /** 网页全屏方式（mobile），默认：none */
        fullScreenOrientation?: 'landscape' | 'portrait' | 'none';
        /** vrm 播放器是否清空控制台日志，默认：true */
        pbg?: boolean;
    }

    declare type VodPlayerCommonEvents = 's2j_onPlayerInitOver' | 's2j_onVideoPlay' | 's2j_onVideoPause' | 's2j_onPlayOver' | 'statisticsInfo' | 'serverError';

    /**
     * 点播播放器自定义域名参数
     */
    declare interface VodPlayerDomainInfoOptions {
        /**
         * videojson 请求域名
         * @default player.polyv.net
         * */
        player?: string;
        /**
         * js资源域名
         * @default player.polyv.net
         * */
        playerJs?: string;
        /**
         * 备用 videojson 域名
         * @default static.polyv.net
         * */
        playerBackup?: string;
        /**
         * 备用 videojson 域名
         * @default static.polyv.net
         * */
        static?: string;
        /**
         * 授权验证接口
         * @default v3.polyv.net
         * */
        v3?: string;
        /**
         * 密码功能验证接口
         * @default v.polyv.net
         * */
        v?: string;
        /**
         * 测试环境
         * @default beta.polyv.net
         * */
        beta?: string;
        /**
         * hls加密视频
         * @default hls.videocc.net
         * */
        hlsKey?: string;
        /**
         * 日志&qos质量监控域名
         * @default prtas.videocc.net
         * */
        rtas?: string;
        /**
         * 日志&qos质量监控备用域名
         * @default prtas-2.videocc.net
         * */
        rtasBackUp?: string;
        /**
         * 跨段续播域名
         * @default script.polyv.net
         * */
        scriptPolyv?: string;
    }

    declare type VodPlayerEvents = VodPlayerCommonEvents | VodPlayerPcEvents | VodPlayerMobileEvents;

    declare interface VodPlayerFlashOptions {
        /** 是否使用 flash 播放器 */
        flash?: boolean;
    }

    /**
     * 点播播放器实例
     */
    declare interface VodPlayerInstance {
        /** 播放器版本号 */
        readonly version: string;
        /** 视频清晰度最高等级 */
        readonly levels: number;
        /** 当前的清晰度等级 */
        readonly currentLevel: number;
        /** 移动端：获取视频清晰度最高等级 */
        getQualityLevels(): number;
        /** 移动端：获取当前清晰度 */
        getCurrentLevel(): number;
        /** 修改清晰度 */
        changeLevel(level: number): void;
        /** 当前倍速 */
        readonly currentRate: number;
        /** 修改倍速 */
        changeRate(rate: number): void;
        /** 获取总线路数 */
        readonly lines: number;
        /** 获取当前线路 */
        readonly currentLine: number;
        /** pc 播放器实例 */
        HTML5?: {
            video: HTMLVideoElement;
        };
        /** 切换线路 */
        changeLine(line: number): number;
        /** 获取播放总时长 */
        j2s_getDuration(): number;
        /** 获取当前播放时长 */
        j2s_getCurrentTime(): number;
        /** 播放 */
        j2s_resumeVideo(): void;
        /** 暂停 */
        j2s_pauseVideo(): void;
        /** 设置音量 */
        j2s_setVolume(volume: number): void;
        /** 显示弹幕 */
        j2s_showBarrage(): void;
        /** 隐藏弹幕 */
        j2s_hideBarrage(): void;
        /** 添加弹幕 */
        j2s_addBarrageMessage(str: string | DanmuAddOptions): void;
        /** seek 播放进度 */
        j2s_seekVideo(time: number): void;
        /**
         * 修改统计参数
         * @param session_id 用户 id
         * @param param1 场次号
         * @param param2 昵称
         * @param param3
         * @param param4
         */
        changeStatistics(session_id?: string | boolean, param1?: string | boolean, param2?: string, param3?: string, param4?: string): void;
        /** 获取播放器统计信息 */
        getStatisticInfo(): PlayerStatisticsInfoCbParams;
        /** 退出网页全屏 */
        exitWebPageFullScreen(): void;
        /** 获取小窗状态 */
        getPictureInPictureStatus(): boolean;
        /** 进入小窗 */
        enterPictureInPicture(): Promise<PictureInPictureWindow>;
        /** 离开小窗 */
        leavePictureInPicture(): Promise<void>;
        /** 切换小窗 */
        togglePictureInPicture(): void;
        /** 切换回放 */
        changeVid(params: ChangeVidParams): void;
        on(event: VodPlayerEvents, fn: (...args: any[]) => void): void;
        once(event: VodPlayerEvents, fn: (...args: any[]) => void): void;
        /** 销毁播放器 */
        destroy(): void;
    }

    /**
     * 点播播放器语言参数
     */
    declare interface VodPlayerLangOptions {
        /** 多语言 */
        lang?: 0 | 1 | string;
    }

    declare type VodPlayerMobileEvents = 's2j_onFullScreen' | 's2j_onNormalScreen' | 'controlDisplay';

    /**
     * 点播播放器选项
     */
    declare interface VodPlayerOptions extends VodPlayerBasicOptions, VodPlayerAuthOptions, VodPlayerBarrageOptions, VodPlayerLangOptions, VodPlayerFlashOptions, VodPlayerStatisticsOptions, VodPlayerUIOptions, VodPlayerSafeOptions, VodPlayerPictureInPictureOptions {
        /** 点播 vid */
        vid?: string;
    }

    /**
     * 点播 PC 播放器事件
     */
    declare type VodPlayerPcEvents = 's2j_volumeChange' | 'levelChange' | 'rateChange' | 's2j_barrageStatus' | 's2j_onPlayStart' | 'enterpictureinpicture' | 'leavepictureinpicture';

    declare interface VodPlayerPictureInPictureOptions {
        /** 是否开启小窗播放 */
        pictureInPicture?: boolean;
        pictureInPictureLevel?: number;
    }

    declare interface VodPlayerSafeOptions {
        /** 加密 token（PC 端） */
        playsafe?: string;
        /** 签名（移动端） */
        sign?: string;
        /** 时间戳（移动端） */
        ts?: number;
    }

    declare interface VodPlayerStatistics {
        /** userId */
        session_id?: string;
        /** 场次号 */
        param1?: string;
        /** 昵称 */
        param2?: string;
        param3?: 'vod';
        param4?: string;
        param5?: string;
    }

    declare interface VodPlayerStatisticsOptions {
        statistics?: VodPlayerStatistics;
    }

    declare interface VodPlayerUIOptions {
        /** 控制栏位置，0-不显示，1-视频内，2-视频外 */
        skinLocation?: 0 | 1 | 2;
        /** 是否屏蔽皮肤进度条 */
        ban_skin_progress?: boolean;
        /** 皮肤设置 */
        skinConfig?: {
            /** 播放按钮图片 */
            playBtnImg?: string;
            /** 是否显示播放按钮 */
            showPlayBtn?: boolean;
            /** 是否显示设置按钮 */
            showSetting?: boolean;
            /** 是否显示 裸眼/眼睛 模式切换按钮 */
            showVrMode?: boolean;
            /** 是否显示 全景/视频 切换按钮 */
            showVrChange?: boolean;
        };
    }

    /**
     * 点播加密播放签名数据
     */
    export declare interface VodPlayTokenData {
        /** 播放 token（PC 端） */
        token: string;
        /** 签名（移动端） */
        sign: string;
        /** 时间戳（移动端） */
        ts: number;
        /** 是否是 VRM12/13 视频 */
        vrm: boolean;
    }

    export declare interface WaitReplaceAskMsgItem {
        id: string;
        askMsg: AskMsgType;
    }

    export declare type WaitReplaceAskMsgList = WaitReplaceAskMsgItem[];

    /**
     * 暖场类型
     */
    export declare enum WarmUpType {
        /**
         * 图片
         */
        Image = "image",
        /**
         * 视频
         */
        Video = "video"
    }

    /**
     * 观看页 SDK 核心类
     */
    declare class WatchCore {
        /**
         * 事件触发器
         */
        eventEmitter: EventEmitter<PolyvWatchCoreEventsRelations, PolyvWatchCoreEvents>;
        /**
         * 销毁标识位
         */
        private __isDestroyed;
        /**
         * @internal
         * @ignore
         * @version v1.10.0
         */
        getClientId(): string;
        /**
         * 判断实例是否已销毁
         * @internal
         * @ignore
         */
        isDestroyed(): boolean;
        /**
         * 配置参数
         */
        private __appConfig;
        /**
         * 获取依赖的应用配置
         * @internal
         * @ignore
         */
        getAppConfig(): Partial<AppConfig>;
        /**
         * 获取额外的业务信息
         * @version v2.15.0
         */
        getExtBusinessInfo(): Promise<ExtBusinessInfo>;
        /**
         * 获取加载环境
         *
         * 通过 {@link createWatchCore} 创建核心实例时可传入 `env` 环境配置，创建后通过 `getSdkLoaderEnv` 获取环境，开发者一般不需要传入该配置。
         * @internal
         * @ignore
         * @example
         * ```js
         * import { createWatchCore, SdkLoaderEnv } from '@polyv/live-watch-sdk';
         *
         * const watchCore = createWatchCore({
         *   env: SdkLoaderEnv.Prod,
         * });
         * console.log(watchCore.getSdkLoaderEnv());
         * ```
         */
        getSdkLoaderEnv(): SdkLoaderEnv;
        /**
         * 获取保利威账号 Id
         * @internal
         * @ignore
         */
        getAccountId(): string;
        /**
         * 获取账户信息
         * @version v1.2.0
         */
        getAccountInfo(): AccountInfo;
        /** 观看条件模块 */
        auth: PlvAuthModule;
        /** 弹幕模块 */
        barrage: PlvBarrageModule;
        /** 连麦模块 */
        connectMic: PlvConnectMicModule;
        /** 频道模块 */
        channel: PlvChannelModule;
        /** 菜单模块 */
        menu: PlvMenuModule;
        /** 聊天室模块 */
        chat: PlvChatModule;
        /** 文档模块 */
        doc: PlvDocModule;
        /** 打赏模块 */
        donate: PlvDonateModule;
        /** 报名观看模块 */
        enroll: PlvEnrollModule;
        /** 互动接收端模块 */
        interactReceive: PlvInteractReceiveModule;
        /** 直播预约模块 */
        liveBooking: PlvLiveBookingModule;
        /** 跑马灯模块 */
        marquee: PlvMarqueeModule;
        /** 分会场模块 */
        multiMeeting: PlvMultiMeetingModule;
        /** 播放器模块 */
        player: PlvPlayerModule;
        /** 短信模块 */
        sms: PlvSmsModule;
        /** 工具模块 */
        utils: PlvUtilsModule;
        /** 微信模块 */
        weixin: PlvWeixinModule;
        /** 邀请模块 */
        invite: PlvInviteModule;
        /** 用户模块 */
        user: PlvUserModule;
        /** 红包模块 */
        redpack: PlvRedpackModule;
        /** 提现模块 */
        withdraw: PlvWithdrawModule;
        /** 回放模块 */
        playback: PlvPlaybackModule;
        /** 分享模块 */
        share: PlvShareModule;
        /** 提问模块 */
        ask: PlvAskModule;
        /** 微活动模块 */
        microActivity: PlvMicroActivityModule;
        /** 试看模块 */
        trial: PlvTrialModule;
        /** 水印模块 */
        watermark: PlvWatermarkModule;
        /** 日志模块 */
        logger: PlvLoggerModule;
        /** 金融-风险确认模块 */
        financeRiskConfirm: PlvFinanceRiskConfirmModule;
        /** 金融-风险测评模块 */
        financeRiskEvaluation: PlvFinanceRiskEvaluationModule;
        /** 数据埋点模块 */
        rtas: PlvRtasModule;
        /** 域名处理模块 */
        domain: PlvDomainModule;
        /** 验证授权模块 */
        verify: PlvVerifyModule;
        /** 时间轴标记(打点)模块 */
        timeAxisMarkModule: PlvTimeAxisMarkModule;
        /** 实时字幕模块 */
        subtitle: PlvSubtitleModule;
        /**
         * 保利威 AI 模块
         * @version v0.10.0
         * */
        polyvAI: PolyvAIModule;
        /**
         * 一客一码模块
         * @version v0.12.0
         */
        saleInvite: PlvSaleInviteModule;
        /**
         * 身份模块
         * @version v1.2.0
         */
        identity: PlvIdentityModule;
        /**
         * 任务活动模块
         * @version v1.5.0
         */
        taskActivity: PlvTaskActivityModule;
        /**
         * 订单模块
         * @version v1.5.0
         */
        order: PlvOrderModule;
        /**
         * 表情模块
         * @version v2.0.0
         */
        emotion: PlvEmotionModule;
        /**
         * 商品 SDK 模块
         */
        product: PlvProductModule;
        /**
         * SDK 加载器
         * @internal
         * @ignore
         * */
        sdkLoader: PlvSdkLoader;
        /**
         * 聊天室 api 请求器
         * @internal
         * @ignore
         */
        chatApi: ChatApi;
        /**
         * 直播 api 请求器
         * @internal
         * @ignore
         */
        polyvApi: PolyvApi;
        /**
         * 直播观看页 api 请求器
         * @internal
         * @ignore
         */
        polyvWatchApi: PolyvWatchApi_2;
        /**
         * normal api 请求器
         * @internal
         * @ignore
         */
        normalApi: NormalApi;
        /**
         * 基础请求器（无baseUrl）
         * @internal
         * @ignore
         */
        basicApi: ApiQuery_2;
        /**
         * 获取授权 token
         * @internal
         * @ignore
         */
        getXAuthToken(): string | undefined;
        /**
         * 设置授权 token
         * @description 从 v1.1.0 开始对外使用
         * @param xAuthToken 授权 token
         */
        setXAuthToken(xAuthToken: string): void;
        /**
         * 获取观看页入口缓存在本地的信息
         */
        private __getSaaSWatchEntranceInfo;
        /**
         * @internal
         * @ignore
         * @version v2.0.0
         */
        isUseShareAuthToken(): boolean;
        /**
         * 冻结状态，默认 false
         * @desc sdk 内部用于停止接口轮询（定时器依旧存在，只是不会再执行回调）
         */
        private __freezed;
        /**
         * @internal
         * @ignore
         * @version v2.0.0
         */
        isSdkFreezed(): boolean;
        /**
         * 冻结模块
         * @version v2.0.0
         */
        freeze(): void;
        /**
         * 解冻结模块
         * @version v2.0.0
         */
        unFreeze(): void;
        constructor(appConfig: AppConfig);
        /**
         * 安装观看页核心
         *
         * 观看页核心方法，用于安装观看页核心并加载频道信息，安装完成后回调 Promise 及 {@link PolyvWatchCoreEvents.WatchCoreSetuped} 事件。
         * @example
         * ```js
         * import { createWatchCore } from '@polyv/live-watch-sdk';
         *
         * const watchCore = createWatchCore({
         *   channelId: '频道号'
         * });
         * watchCore.setup();
         * ```
         */
        setup(): Promise<void>;
        /**
         * 是否已触发连接聊天室的标志位
         * @version v2.11.0
         */
        private __connected;
        /**
         * 断开聊天室连接
         *
         * 完全断开聊天室 socket 连接，并销毁聊天室核心实例，慎用！
         *
         * @version v2.11.0
         * @example
         * ```js
         * await watchCore.disconnect();
         * console.log('断联成功');
         * ```
         */
        disconnect(): Promise<void>;
        /**
         * 连接聊天室
         *
         * 观看页核心方法，用于在进入直播观看页之前连接聊天室，连接完成后回调 Promise 及 {@link PolyvWatchCoreEvents.WatchCoreConnected} 事件。
         *
         * 默认情况下，该方法只被调用一次，如果需要多次调用，请先执行 `watchCore.disconnect` 方法。如果只需要临时断联 socket，可以通过 `watchCore.chat.getSocket()` 获取实例进行操作
         *
         * @example
         * ```js
         * await watchCore.connect();
         * console.log('连接成功，显示直播观看页');
         * ```
         */
        connect(): Promise<void>;
        /**
         * 更新核心配置
         *
         * 通过 `updateAppConfig` 更新核心配置，如切换多语言
         * @warn 不支持更新 uniqueId、env、sdkIntegration 配置，只能在创建时传入
         * @param appConfig 新的配置
         * @example
         * ```js
         * // 设为英语
         * watchCore.updateAppConfig({
         *   language: 'en',
         * });
         * ```
         */
        updateAppConfig(appConfig: Partial<OmitAppConfig>): void;
        /** 是否通过 vid 观看回放 */
        private __isPlaybackWatchByVid;
        /**
         * 是否为回放观看页模式
         *
         * 调用 `createWatchCore` 并传入回放 vid，页面将为回放模式，此时通过 `isPlaybackWatchByVid` 判断。
         * @warn 在 v0.6.0 之前的版本，需要在进入观看页后才有效，引导页暂时不能根据该标识位判断
         * @returns 是否回放观看页模式
         * @example
         * ```js
         * const watchCore = createWatchCore({
         *   channelId: '频道号',
         *   vid: '回放 vid',
         * });
         *
         * console.log(watchCore.isPlaybackWatchByVid()); // true
         * ```
         */
        isPlaybackWatchByVid(): boolean;
        /**
         * 设置"是否通过 vid 观看回放"
         */
        private __setIsPlaybackWatchByVid;
        /**
         * 获取通过 vid 观看回放的基础信息
         * @version v0.6.0
         */
        getPlaybackWatchBasicInfo(): PlaybackWatchBasicInfo;
        /**
         * 是否处于指定场次的观看页中
         */
        private __inTargetSession;
        /**
         * @version v2.4.0
         * @internal
         * @ignore
         */
        inTargetSession(): boolean;
        private __setInTargetSession;
        /**
         * 获取当前直播新场次Id
         * @version v2.6.0
         * @internal
         * @ignore
         */
        getCurrentTargetSessionId(): string | undefined;
        /** 获取微信 SDK 方法 */
        private __getWeixinSdk?;
        /**
         * 设置微信 SDK 获取函数
         * @version v1.10.0
         */
        setWeixinSdk(getWeixinSdk: () => Promise<WechatJsSdk.Wx | undefined>): void;
        /**
         * 获取设置到 core 的微信 SDK 获取函数
         * @version v1.10.0
         */
        getWeixinSdk(): (() => Promise<WechatJsSdk.Wx | undefined>) | undefined;
        /**
         * 销毁观看页核心实例
         * @internal
         * @ignore
         */
        destroy(): Promise<void>;
    }

    /** 泛域名支付类型与参数关系 */
    export declare type WatchDomainPayParamsRelation = {
        /** 付费观看 */
        [WatchDomainPayType.AuthPay]: Record<string, never>;
        /** 打赏 */
        [WatchDomainPayType.Donate]: PayDonateParams;
        /** 发送红包 */
        [WatchDomainPayType.Redpack]: SubmitSendRedpackParams;
    };

    /** 泛域名支付类型 */
    export declare enum WatchDomainPayType {
        /** 打赏 */
        Donate = "donate",
        /** 观看条件-付费观看 */
        AuthPay = "purchase",
        /** 发送红包 */
        Redpack = "redpack"
    }

    /**
     * 语言类型枚举
     */
    export declare enum WatchSdkLangEnum {
        /** 简体中文 */
        ZH_CN = "zh_CN",
        /** 繁体中文 */
        ZH_TW = "zh_TW",
        /** 英文 */
        English = "en",
        /** 日语 */
        Japanese = "ja",
        /** 韩语 */
        Korean = "ko",
        /** 俄语 */
        Russian = "ru"
    }

    /** 水印显示类型 */
    export declare enum WatermarkDisplayType {
        Player = "player",
        Fullscreen = "fullscreen"
    }

    /**
     * 水印字体大小
     */
    export declare enum WatermarkFontSize {
        /**
         * 大
         */
        Large = "large",
        /**
         * 中
         */
        Middle = "middle",
        /**
         * 小
         */
        Small = "small"
    }

    /**
     * 水印设置
     */
    export declare interface WatermarkSetting {
        /**
         * 水印开关
         */
        watermarkEnabled: boolean;
        /**
         * 水印类型
         */
        watermarkType: WatermarkType;
        /**
         * 水印不透明度（0～1）
         */
        watermarkOpacity: number;
        /**
         * 水印字体大小
         */
        watermarkFontSize: WatermarkFontSize;
        /**
         * 水印内容，水印类型为 {@link WatermarkType.Nickname} 时返回当前用户昵称
         */
        watermarkContent: string;
        /** 水印显示类型 */
        watermarkDisplayType: WatermarkDisplayType;
        /** 水印颜色 */
        watermarkColor: string;
    }

    /**
     * 水印实例对象
     */
    export declare interface WatermarkTarget {
        /** 水印标识 */
        id: string;
        /** 水印实例 */
        watermarkInstance: PlayerWatermark;
        /** 设置水印内容 */
        setContent: (content: string) => void;
        /** 销毁当前对象 */
        destroyTarget: () => void;
    }

    /**
     * 水印类型
     */
    export declare enum WatermarkType {
        /**
         * 固定值
         */
        Fixed = "fixed",
        /**
         * 用户昵称
         */
        Nickname = "nickname"
    }

    declare interface WebSdkDomainInfo {
        /**
         * 播放器 sdk 域名，仅用来加载播放器
         * @default https://player.polyv.net
         */
        playerSdkDomain: string;
        /**
         * web sdk 域名
         * @default https://websdk.videocc.net
         */
        webSdkDomain: string;
        /**
         * @internal
         * @ignore
         */
        webSdkTest1Domain: string;
        /**
         * @internal
         * @ignore
         */
        webSdkTest2Domain: string;
        /**
         * @internal
         * @ignore
         */
        webSdkTest3Domain: string;
        /**
         * @internal
         * @ignore
         */
        webSdkTest4Domain: string;
        /**
         * @internal
         * @ignore
         */
        webSdkTest5Domain: string;
    }

    /**
     * 微信授权跳转地址数据
     */
    export declare interface WeixinAuthRedirectUrlData {
        /** 跳转的微信授权地址 */
        authorizeRedirectUrl?: string;
    }

    /**
     * 微信授权跳转地址数据
     */
    declare interface WeixinAuthRedirectUrlData_2 {
        /** 跳转的微信授权地址 */
        authorizeRedirectUrl?: string;
    }

    export declare interface WeixinConfig {
        /** 微信支付类型 */
        weixinPayType: WeixinPayType;
        /** 是否支持在微信环境下重新设置昵称 */
        weixinResetNickEnabled: boolean;
    }

    /**
     * 微信模块
     * @class
     */
    declare class WeixinModule extends PlvWorkWeixinModule_2 {
        /**
         * 判断当前是否为微信快照用户
         * @version v0.6.0
         * @internal
         * @ignore
         */
        isWeixinSnapshotUser(): boolean;
        /**
         * 是否已进行微信(静默)授权
         * @description 检查当前用户是否已完成微信静默授权
         * @returns 是否已完成微信静默授权
         * */
        isWeixinAuthorized(): boolean;
        /**
         * 是否已进行微信非静默授权
         * @description 检查当前用户是否已完成微信非静默授权（授权获取用户信息）
         * @returns 是否已完成微信非静默授权
         * */
        isWeixinWatchAuthorized(): boolean;
        /**
         * 获取微信授权跳转地址
         * @internal
         * @ignore
         */
        getWeixinAuthorizeRedirectUrl(options?: GetWeixinAuthorizeRedirectUrlOptions_2): Promise<WeixinAuthRedirectUrlData_2>;
        /**
         * 跳转到微信授权地址
         * @description 执行微信授权跳转，跳转前会先获取授权地址
         * @param {RedirectWeixinAuthorizeUrlOptions} options 授权跳转配置
         * @returns
         */
        redirectWeixinAuthorizeUrl(options?: RedirectWeixinAuthorizeUrlOptions_2): Promise<void>;
        /**
         * 获取微信签名数据
         * @description 获取微信JS-SDK所需的签名信息
         * @returns 微信签名数据
         */
        getWeixinSign(): Promise<WeixinSignData_2>;
        /**
         * 确保微信/企微静默授权：按需跳转或返回已完成
         * @description 检查并确保微信或企业微信已完成静默授权，如果没有则执行跳转
         * @param {EnsureWxAuthOptions} options 授权选项，包括环境判断函数等
         * @returns 是否执行了跳转
         */
        ensureWorkWxSnsAuth(options?: EnsureWxAuthOptions): Promise<{
            redirected: boolean;
        }>;
    }

    /**
     * 微信付款类型
     */
    export declare enum WeixinPayType {
        /** 商家转账到零钱 */
        Merchant = "merchant",
        /** 商家转账 */
        TransferBill = "merchant_transfer",
        /** 企业付款到零钱 */
        Enterprise = "enterprise"
    }

    /** 微信签名数据 */
    export declare interface WeixinSignData extends WxShareInfo {
        /** 微信 js-sdk 签名信息 */
        wxSign: WxJsApiSignature;
    }

    /** 微信签名数据 */
    declare interface WeixinSignData_2 extends WxJsApiSignature_2 {
    }

    /** 提现配置 */
    export declare interface WithdrawConfig {
        /** 是否可以提现 */
        withdrawEnabled: boolean;
        /** 最小提现额度 */
        withdrawMinAmount: number;
        /** 最大提现额度 */
        withdrawMaxAmount: number;
    }

    /**
     * 提现记录
     */
    export declare interface WithdrawRecord {
        /** 提现 id */
        withdrawId: string;
        /** 提现金额，单位：元 */
        amount: number;
        /** 申请时间 */
        applyTime: number;
        /** 提现状态 */
        status: WithdrawStatus;
        /** 微信用户确认签名信息 */
        confirmSignData?: WxMerchantTransferSignData;
        /** 提现错误码 */
        outTradeErrCode?: string;
        /** 提现错误码描述 */
        outTradeErrCodeDes?: string;
    }

    /**
     * 提现状态
     */
    export declare enum WithdrawStatus {
        /** 提现成功 */
        Finish = "FINISH",
        /** 等待提现 */
        WaitPay = "WAIT_PAY",
        /** 等待用户确认 */
        WaitUserConfirm = "WAIT_USER_CONFIRM",
        /** 提现中 */
        InPay = "PROCESSING",
        /** 提现失败 */
        Fail = "ERROR"
    }

    export declare interface WorkWeixinAuthorizeCodeData {
        /** 企业微信的 corpId */
        corpId: string;
        /** 授权方的网页应用 id */
        agentId: string;
        /** 跳转 url */
        redirectUrl: string;
        /** 回调参数 */
        state: string;
    }

    declare interface WorkWeixinAuthorizeCodeData_2 {
        /** 企业微信的 corpId */
        corpId: string;
        /** 授权方的网页应用 id */
        agentId: string;
        /** 跳转 url */
        redirectUrl: string;
        /** 回调参数 */
        state: string;
    }

    export declare interface WorkWeixinFriendConfig {
        /** 二维码链接 */
        qrCodeHref: string;
        /** 二维码标题 */
        qrCodeTitle: string;
        /** 二维码描述 */
        qrCodeDescription: string;
    }

    declare interface WorkWeixinSetting {
        /** 企微是否已过期 */
        enterpriseWechatExpire: boolean;
        /** 是否绑定企微 */
        wxWorkStatusSwitch: boolean;
        /** 企微授权开关 */
        wxWorkAuthSwitch: boolean;
        /** (超管)企微员工邀请开关 */
        wxWorkInviteEnabled: boolean;
        /** 企微好友观看限制开关 */
        wxWorkFriendWatchEnabled: boolean;
    }

    /**
     * 微信预约信息
     */
    export declare interface WxBooking {
        /** 微信预约人数 */
        bookingCount: number;
        /** 微信预约开关 */
        bookingEnabled: YN;
        /** 是否已订阅公众号 */
        isSubscribed: YN | null;
        /** 是否已预约 */
        isWxBooking: YN | null;
        /** 微信公众号图片 */
        weixinMpImgUrl: string | null;
    }

    /**
     * 企微授权信息
     */
    export declare interface WxCpUserInfo {
        /** 头像 */
        avatar: string;
        /** 昵称 */
        nickName: string;
        /**
         * 是否企微好友
         * @desc 实际企微好友等于外部联系人
         */
        wxWorkFriend: YN;
        /** 添加好友二维码 */
        friendQrCode: string;
        /** 添加好友二维码-标题 */
        qrCodeTitle: string;
        /** 添加好友二维码-描述 */
        qrCodeDescription: string;
        /** 企微观看条件是否验证通过 */
        enterpriseWatchEnabled: YN;
        /** 企微外部联系人 Id */
        externalUserId: string | null;
    }

    /**
     * 企微用户信息
     */
    declare interface WxCpUserInfo_2 {
        /** 头像 */
        avatar: string;
        /** 昵称 */
        nickName: string;
        /**
         * 是否企微好友
         * @description 实际企微好友等于外部联系人
         */
        wxWorkFriend: YN_2;
        /** 添加好友二维码 */
        friendQrCode: string;
        /** 添加好友二维码-标题 */
        qrCodeTitle: string;
        /** 添加好友二维码-描述 */
        qrCodeDescription: string;
        /** 企微观看条件是否验证通过 */
        enterpriseWatchEnabled: YN_2;
        /** 企微外部联系人 Id */
        externalUserId: string | null;
    }

    /**
     * 微信信息
     */
    export declare interface WxInfo {
        /** 微信 openId */
        openId: string | null;
        /** 微信用户信息 */
        wxUser: WxUserInfo | null;
        /** 企业微信成员用户 id */
        wxWorkUserId: string | null;
        /** 非企业成员的标识 （只要做过企微静默就会有得标识） */
        cpOpenId: string | null;
        /** 企微授权信息 - 可能是员工或外部联系人 */
        wxCpUser: WxCpUserInfo | null;
        /** 是否为快照页用户 */
        isSnapshotUser: null | YN;
        /**
         * 用户绑定状态
         * @desc 和用户体系相关，Y-已被其他账号绑定
         */
        cpUserBindStatus: YN;
        /**
         * 是否完成企微静默授权
         * @desc 完成非静默授权时，该值也会为 true
         */
        cpSnsbase: boolean;
    }

    /**
     * 微信信息
     */
    declare interface WxInfo_2 {
        /** 微信 openId */
        openId: string | null;
        /** 微信用户信息 */
        wxUser: WxUserInfo_2 | null;
        /** 企业微信成员用户 id */
        wxWorkUserId: string | null;
        /** 非企业成员的标识 */
        cpOpenId: string | null;
        /** 企微用户信息 */
        wxCpUser: WxCpUserInfo_2 | null;
        /** 是否为快照页用户 */
        isSnapshotUser: null | YN_2;
        /**
         * 是否完成企微静默授权
         * @description 完成非静默授权时，该值也会为 true
         */
        cpSnsbase: boolean;
    }

    /** 微信 js-sdk 签名信息类型 */
    export declare interface WxJsApiSignature {
        appId: string;
        nonceStr: string;
        signature: string;
        timestamp: number;
    }

    /** 微信 js-sdk 签名信息类型 */
    declare interface WxJsApiSignature_2 {
        appId: string;
        nonceStr: string;
        signature: string;
        timestamp: number;
    }

    export declare interface WxLiveBookingOptions {
        /** 其他频道 id */
        otherChannelId?: string;
    }

    /**
     * 微信确认收款签名信息
     */
    export declare interface WxMerchantTransferSignData {
        /** 提现 id */
        withdrawId: string;
        /** 应用 id */
        appId: string;
        /** 商户号 id */
        mchId: string;
        /** 签名参数 */
        packageInfo: string;
        /** 提现单号 */
        outBillNo: string;
    }

    /** 微信支付签名类型 */
    export declare interface WxPaySignData {
        /** 支付签名时间戳 */
        timestamp: number;
        /** 支付签名随机串 */
        nonceStr: string;
        /** 支付参数 */
        package: string;
        /** 签名方式 */
        signType: string;
        /** 支付签名 */
        paySign: string;
    }

    /** 微信分享信息 */
    export declare interface WxShareInfo {
        /** 是否使用微信自定义分享地址 */
        isUseWxShareUrl: YN;
        /** 是否开启微信自定义分享地址参数 */
        weixinShareCustomUrlWithParamEnabled: YN;
        /** 微信分享地址 */
        wxShareUrl: string;
        /** 分享图标 */
        weixinShareCoverImg: string;
        /** 分享描述 */
        shareDesc: string;
        /** 分享标题 */
        shareTitle: string;
    }

    /**
     * 微信用户信息
     */
    export declare interface WxUserInfo {
        /** 微信头像 */
        headImgUrl: string;
        /** 微信昵称 */
        nickname: string;
    }

    /**
     * 微信用户信息
     */
    declare interface WxUserInfo_2 {
        /** 微信头像 */
        headImgUrl: string;
        /** 微信昵称 */
        nickname: string;
    }

    /**
     * @file 常规枚举
     */
    /** 开关枚举 */
    export declare enum YN {
        Y = "Y",
        N = "N"
    }

    /**
     * @file 常规枚举
     */
    /** 开关枚举 */
    declare enum YN_2 {
        Y = "Y",
        N = "N"
    }

    declare type YN_3 = 'Y' | 'N';

    /**
     * @file 常规枚举
     */
    /** 开关枚举 */
    declare enum YN_4 {
        Y = "Y",
        N = "N"
    }

    /** 网络类型 */
    export declare type ZoneType = 'in' | 'out';

    export { }