@byteplus/veplayer 1.18.0-rc.5 → 1.18.0-rc.6

package/lite.d.ts

@@ -0,0 +1,644 @@
+import { I18N } from 'xgplayer';
+
+/** UMD modules that can be loaded or explicitly pre-registered. */
+export declare enum UmdKeys {
+	HLS = "hls",
+	HLSJS = "hlsjs",
+	FLV = "flv",
+	XGVideo = "XGVideo",
+	HLSEncrypt = "hlsEncrypt",
+	DASH = "dash",
+	MP4Encrypt = "mp4Encrypt",
+	DanmuJS = "danmujs",
+	DanmuMask = "danmuMask",
+	StreamProbe = "streamprobe",
+	VeStrategy = "vestrategy",
+	VeStrategyH265 = "vestrategy_h265",
+	VeStrategyPreload = "vestrategy_preload",
+	VeStrategyAdaptRange = "vestrategy_adapt_range",
+	DashAbralgo = "DashAbralgo",
+	Preloader = "preloader",
+	HLSjsPro = "hlsjsPro"
+}
+/** Resolved UMD module values keyed by their public UMD key. */
+export type UmdModules = Partial<Record<UmdKeys, unknown>>;
+/** Video and audio codec names supported by the player. */
+export declare const CodecType: {
+	readonly H264: "h264";
+	readonly H265: "h265";
+	readonly H266: "h266";
+	readonly AAC: "aac";
+	readonly MP3: "mp3";
+	readonly OPUS: "opus";
+	readonly UNKNOWN: "unknown";
+};
+/** MIME type mapping for the supported MSE video codecs. */
+export declare const ContentType: {
+	readonly h265: string;
+	readonly h264: string;
+};
+export declare enum EVideoFormat {
+	MP4 = "mp4",
+	DASH = "dash",
+	HLS = "hls"
+}
+export declare enum EAudioFormat {
+	M4A = "m4a",
+	MP4 = "mp4",
+	MP3 = "mp3",
+	DASH = "dash",
+	HLS = "hls",
+	OGG = "ogg"
+}
+export declare const enum EDRMTYPE {
+	DRM_ENCRYPT = "drm_encrypt",
+	PRIVATE_ENCRYPT = "private_encrypt",
+	PRIVATE_ENCRYPT_UPGRADE = "private_encrypt_upgrade",
+	STANDARD_ENCRYPT = "standard_encrypt"
+}
+/** Plugin placement values compatible with the Full entry. */
+export declare const enum POSITIONS {
+	ROOT = "root",
+	ROOT_LEFT = "rootLeft",
+	ROOT_RIGHT = "rootRight",
+	ROOT_TOP = "rootTop",
+	CONTROLS_LEFT = "controlsLeft",
+	CONTROLS_RIGTH = "controlsRight",
+	CONTROLS_RIGHT = "controlsRight",
+	CONTROLS_CENTER = "controlsCenter",
+	CONTROLS = "controls"
+}
+/** Public event-name map shared by Lite and Full UMD constructors. */
+export interface LiteEvents {
+	readonly READY: "ready";
+	readonly [eventName: string]: string;
+}
+/** Legacy grouped event-name map. */
+export interface LiteEvent {
+	readonly SDKEvents: LiteEvents;
+	readonly PluginEvents: Record<string, string>;
+}
+export declare const Events: LiteEvents;
+export declare const Event: LiteEvent;
+export type LiteStreamType = "mp4" | "hls" | "dash" | "flv";
+export type LiteCodecType = "h264" | "h265" | "h266" | "aac" | "mp3" | "opus" | "unknown";
+export type LiteDrmType = "drm_encrypt" | "private_encrypt" | "private_encrypt_upgrade" | "standard_encrypt";
+export interface LiteUrlSource {
+	src: string;
+	type?: string;
+	[key: string]: unknown;
+}
+export type LiteMediaUrl = string | LiteUrlSource[];
+type UnsupportedFileUrl = `${string}.sdp` | `${string}.sdp?${string}` | `${string}.sdp#${string}`;
+type LiteUrlString<Value extends string> = string extends Value ? string : Lowercase<Value> extends UnsupportedFileUrl ? never : Value;
+export type LiteUrl<Value extends LiteMediaUrl = LiteMediaUrl> = Value extends string ? LiteUrlString<Value> : Value extends Array<infer Source> ? Source extends LiteUrlSource ? Array<Omit<Source, "src"> & {
+	src: LiteUrlString<Source["src"]>;
+}> : never : never;
+export interface LiteDefinitionMapItem {
+	definition?: string;
+	definitionTextKey?: string;
+}
+export interface LitePlayAuthTokenConfig {
+	playAuthToken: string;
+	defaultDefinition?: string;
+	playDomain?: string;
+	needPoster?: boolean;
+	needThumbs?: boolean;
+	needDefinitionList?: boolean;
+	keyToken?: string;
+	getKeyType?: string;
+	getDrmAuthToken?: (playAuthIds: string, vid: string, unionInfo: string) => Promise<string>;
+	thirdPartyDrmAuthToken?: string;
+	serverCertificatePath?: string;
+	unRecord?: boolean;
+	reqParams?: Record<string, number | string | boolean>;
+	definitionMap?: Record<string, string | LiteDefinitionMapItem>;
+	retryCount?: number;
+	autoDemoteDefinition?: string;
+	autoDemoteDefinitionTextKey?: string;
+	urlQueryParams?: Record<string, string>;
+}
+/** Lite-only preloading scene values supported by the player runtime. */
+export type LitePreloadScene = 0 | 1;
+/** Lite-safe preload strategy configuration. */
+export interface LitePreloadStrategyConfig {
+	preloadScene?: LitePreloadScene;
+	prevCount?: number;
+	nextCount?: number;
+	preloadTime?: number;
+	preloadMaxCacheCount?: number;
+	Strategy?: unknown;
+	disabled?: boolean;
+}
+/** Lite strategy initialization. Full strategy names are deliberately absent. */
+export interface LiteStrategyInitOptions {
+	/** Optional for a configured short-drama environment. */
+	appId?: number;
+	region?: "cn" | "mya" | "va" | "sg";
+	strategies: {
+		preload?: true | LitePreloadStrategyConfig;
+	};
+	deviceId?: string;
+	plugins?: unknown[];
+	Module?: unknown;
+}
+/** Runtime updates supported for Lite preload scenes. */
+export interface LitePreloadUpdateConfig {
+	prevCount?: number;
+	nextCount?: number;
+}
+/** Lite-safe media information cache settings. */
+export interface LiteMediaInfoCacheConfig {
+	enable?: boolean;
+	cacheType?: "memory" | "localStorage";
+	expireTime?: number;
+	maxEntries?: number;
+}
+/** Current media information cache settings, with defaults resolved. */
+export interface LiteMediaInfoCacheState {
+	enable: boolean;
+	cacheType: "memory" | "localStorage";
+	expireTime: number;
+	maxEntries: number;
+}
+/** Minimal preloader operations available from the Lite static surface. */
+export interface LitePreloaderManager {
+	removeAll(): void;
+	removeAllPreloadTask(): void;
+	clearPreloadList(): void;
+}
+/** Lite preloader lifecycle states. */
+export type LitePreloaderStatus = 0 | 1 | 2 | 3;
+/** Lite-safe view of the strategy controller exposed by the player. */
+export interface LiteVeStrategy {
+	readonly preloader?: LitePreloaderManager;
+	readonly preloaderStatus: LitePreloaderStatus;
+}
+/** Encryption metadata generated by a registered encryption module. */
+export type LiteEncryptInfo = Record<string, unknown>;
+/** A direct media entry accepted by Lite preload APIs. */
+export interface LitePreloadResolvedStream {
+	vid: string;
+	url: string;
+	definition: string;
+	streamType: "mp4";
+	codec: "h264";
+	bitrate: number;
+	duration: number;
+	size: number;
+}
+/** A short-drama episode accepted by Lite preload APIs. */
+export interface LitePreloadDramaStream {
+	vid?: string;
+	albumId: string;
+	episodeId: string;
+	defaultDefinition?: string;
+	getVideoByToken?: LitePlayAuthTokenConfig;
+}
+/** A token-resolved VOD item accepted by Lite preload APIs. */
+export interface LitePreloadAuthTokenStream {
+	vid?: string;
+	defaultDefinition?: string;
+	getVideoByToken: LitePlayAuthTokenConfig;
+}
+/** Lite preload entries do not expose Full strategy stream contracts. */
+export type LitePreloadStream = LitePreloadResolvedStream | LitePreloadDramaStream | LitePreloadAuthTokenStream;
+/** Request passed by the host short-drama bridge. */
+export interface LiteDramaInfoRequest {
+	clientKey: string;
+	albumId: string;
+	episodeId: string;
+	vid: string;
+}
+/** Error returned by the host short-drama bridge. */
+export interface LiteDramaInfoError {
+	error_code: number;
+	error_msg: string;
+	error_extra?: unknown;
+}
+/** Safe VOD fields exposed from a short-drama video result. */
+export interface LiteDramaVideoInfo {
+	version?: number;
+	vid?: string;
+	status?: number;
+	poster_url?: string;
+	duration?: number;
+	file_type?: string;
+	enable_adaptive?: boolean;
+	total_count?: number;
+	adaptive_info?: unknown;
+	adaptive_bitrate_streaming_info?: unknown;
+	play_info_list?: Array<{
+		file_id?: string;
+		md5?: string;
+		file_type?: string;
+		format?: string;
+		codec?: string;
+		definition?: string;
+		main_play_url?: string;
+		backup_play_url?: string;
+		bitrate?: number;
+		width?: number;
+		height?: number;
+		size?: number;
+		duration?: number;
+		drm_type?: string;
+	}>;
+	thumb_info_list?: unknown[];
+	subtitle_info_list?: unknown[];
+}
+/** Short-drama bridge result with only Lite-safe media data. */
+export interface LiteDramaInfoResponse {
+	is_success: number | boolean;
+	error?: LiteDramaInfoError;
+	data?: {
+		status: number;
+		drama_info: {
+			album_id: string;
+			drama_name: string;
+			drama_cover: string;
+			drama_description: string;
+		};
+		episode_info: {
+			episode_id: string;
+			episode_name: string;
+			episode_cover: string;
+			episode_description: string;
+		};
+		video_info: LiteDramaVideoInfo;
+		perf_info?: {
+			prepare_cost?: number;
+			request_cost?: number;
+			parse_cost?: number;
+			total_cost?: number;
+		};
+	};
+}
+/** Host callbacks required by Lite short-drama playback. */
+export interface LiteTTDramaEnv {
+	channel?: "volcengine" | "byteplus";
+	appVersion: string;
+	clientKey: string;
+	canIUseGetDramaInfo: boolean;
+	canAndroidBatchGetDramaInfo?: boolean;
+	getDramaInfo: (callback: (res: LiteDramaInfoResponse) => void, options: LiteDramaInfoRequest) => void;
+	videoSecurityModule?: unknown;
+	sendLog: (eventName: string, params: Record<string, unknown>) => void;
+	getTokenVerifySecret?: () => Promise<string>;
+}
+export interface LiteDefaultConfig {
+	type?: "vod";
+	isLive?: false;
+	lineId?: string | number;
+	definition?: string;
+	startTime?: number;
+	volume?: number | {
+		position?: any;
+		index?: number;
+		disable?: boolean;
+		showValueLabel?: boolean;
+		default?: number;
+		miniVolume?: number;
+	};
+}
+export interface LiteStream<MediaUrl extends LiteMediaUrl = LiteMediaUrl> {
+	definition?: string;
+	mapDefinition?: string;
+	definitionTextKey?: string;
+	codec?: LiteCodecType;
+	lineId?: string | number;
+	lineTextKey?: string;
+	width?: number;
+	height?: number;
+	bitrate?: number;
+	bandwidth?: number;
+	urlExpireTimestamp?: number;
+	kid?: string;
+	secretKey?: string;
+	drmType?: LiteDrmType;
+	streamType?: LiteStreamType;
+	url: MediaUrl & LiteUrl<MediaUrl>;
+}
+export interface LiteSubtitleConfig {
+	list?: LiteSubtitleItem[];
+	defaultSubtitleId?: string | number;
+	defaultSubtitleLanguage?: string | number;
+	updateMode?: "vod";
+	[key: string]: unknown;
+}
+export interface LitePosterConfig {
+	poster: string;
+	isEndedShow?: boolean;
+	hideCanplay?: boolean;
+	notHidden?: boolean;
+	fillMode?: "fixWidth" | "fixHeight" | "cover" | "contain";
+}
+export interface LitePictureInPictureConfig {
+	showIcon?: boolean;
+	preferDocument?: boolean;
+	width?: number;
+	height?: number;
+	docPiPNode?: HTMLElement;
+	docPiPStyle?: string | ((...args: any[]) => string);
+	position?: any;
+	index?: number;
+	disable?: boolean;
+}
+export interface LiteFullscreenConfig {
+	useCssFullscreen?: boolean;
+	rotateFullscreen?: boolean;
+	useScreenOrientation?: boolean;
+	lockOrientationType?: string;
+	target?: HTMLElement;
+	disable?: boolean;
+	needBackIcon?: boolean;
+	switchCallback?: (...args: unknown[]) => unknown;
+}
+export interface LiteCommonStyle {
+	progressColor?: string;
+	playedColor?: string;
+	cachedColor?: string;
+	volumeColor?: string;
+	sliderBtnStyle?: CSSStyleDeclaration;
+}
+export interface LiteMobileConfig {
+	disableGesture?: boolean;
+	gestureX?: boolean;
+	gestureY?: boolean;
+	scopeL?: number;
+	scopeR?: number;
+	darkness?: boolean;
+	maxDarkness?: number;
+	gradient?: "normal" | "none" | "top" | "bottom";
+	isTouchingSeek?: boolean;
+	miniMoveStep?: number;
+	pressRate?: number;
+	disableActive?: boolean;
+	disableTimeProgress?: boolean;
+	hideControlsActive?: boolean;
+	hideControlsEnd?: boolean;
+	moveDuration?: number;
+	closedbClick?: boolean;
+	disablePress?: boolean;
+	disableSeekIcon?: boolean;
+}
+export interface LiteStartConfig {
+	isShowPause?: boolean;
+	isShowEnd?: boolean;
+	disableAnimate?: boolean;
+	mode?: "hide" | "show" | "auto";
+}
+export interface LiteAutoBitrateConfig {
+	enable: boolean;
+	startWithAuto?: boolean;
+	showRealDefinition?: boolean;
+	autoDefinitionText?: string;
+	definitionTextKey?: string;
+	module?: unknown;
+}
+export interface LiteThumbnailConfig {
+	urls: string[];
+	pic_num: number;
+	col: number;
+	row: number;
+	height?: number;
+	width?: number;
+	scale?: 1;
+	className?: string;
+	hidePortrait?: false;
+}
+export interface LiteProgressDot {
+	id: string | number;
+	time: number;
+	text?: string;
+	duration?: number;
+	style?: CSSStyleDeclaration;
+}
+export interface LitePlayerConfig<MediaUrl extends LiteMediaUrl = LiteMediaUrl, StreamUrl extends LiteMediaUrl = LiteMediaUrl> {
+	id?: string;
+	root?: HTMLElement;
+	type?: "vod";
+	isLive?: false;
+	streamType?: LiteStreamType;
+	url?: MediaUrl & LiteUrl<MediaUrl>;
+	playList?: Array<LiteStream<StreamUrl>>;
+	getVideoByToken?: LitePlayAuthTokenConfig;
+	defaultConfig?: LiteDefaultConfig;
+	Subtitle?: LiteSubtitleConfig;
+	vid?: string;
+	albumId?: string;
+	episodeId?: string;
+	onGetMediaInfo?: (...args: unknown[]) => void;
+	onGetDramaInfoPerf?: (...args: unknown[]) => void;
+	autoSubtitle?: boolean;
+	formatAutoSubtitleItem?: any;
+	drmType?: LiteDrmType;
+	encryptSessionId?: string;
+	playAuthId?: string;
+	playAuth?: string;
+	width?: string | number;
+	height?: string | number;
+	volume?: number;
+	autoplay?: boolean;
+	poster?: string | LitePosterConfig;
+	autoplayMuted?: boolean;
+	enableDegradeMuteAutoplay?: boolean;
+	enableWxJsBridgeAutoplay?: boolean;
+	enableUserActionAutoplay?: boolean;
+	loop?: boolean;
+	defaultPlaybackRate?: number;
+	lang?: "zh" | "zh-cn" | "en" | "jp" | "zh-hk";
+	languages?: {
+		[key: string]: Record<string, unknown>;
+	};
+	pip?: LitePictureInPictureConfig | boolean;
+	fullscreen?: LiteFullscreenConfig;
+	alwaysShowDefinition?: boolean;
+	definitionText?: string;
+	definitionTextKey?: string;
+	codec?: LiteCodecType;
+	region?: "cn" | "mya" | "va" | "sg";
+	userRegion?: "cn" | "mya" | "va" | "sg";
+	pluginPublicPath?: string;
+	startTime?: number;
+	playsinline?: boolean;
+	videoAttributes?: Partial<HTMLVideoElement>;
+	fluid?: boolean;
+	fitVideoSize?: "fixWidth" | "fixHeight" | "fixed";
+	videoFillMode?: "auto" | "fillHeight" | "fillWidth" | "fill" | "cover";
+	marginControls?: boolean;
+	commonStyle?: LiteCommonStyle;
+	enableContextmenu?: boolean;
+	closeVideoStopPropagation?: boolean;
+	enableMenu?: boolean;
+	closeVideoClick?: boolean;
+	closeVideoDblclick?: boolean;
+	closeDelayBlur?: boolean;
+	inactive?: number;
+	leavePlayerTime?: number;
+	closePlayVideoFocus?: boolean;
+	closePauseVideoFocus?: boolean;
+	needFullscreenScroll?: boolean;
+	mobile?: LiteMobileConfig;
+	start?: LiteStartConfig;
+	enableHlsMSE?: boolean;
+	useHlsPluginForSafari?: boolean;
+	enableMp4MSE?: boolean;
+	defaultDefinition?: string;
+	plugins?: unknown[];
+	presets?: unknown[];
+	ignores?: string[];
+	isMobile?: boolean;
+	umdUrlMap?: Record<string, string>;
+	unionId?: string;
+	useSoftDecoding?: boolean;
+	enableH265Degrade?: boolean;
+	enableUrlExpireCheck?: boolean;
+	urlExpireTimestamp?: number;
+	urlExpireDiff?: number;
+	urlCheckExpireInterval?: number;
+	onMediaExpired?: () => Promise<any>;
+	onTokenExpired?: () => Promise<LitePlayAuthTokenConfig>;
+	disableVodLogOptsCheck?: boolean;
+	debug?: boolean;
+	sdkErrorPlugin?: any;
+	oriErrRetryCount?: number;
+	oriErrRetryCycle?: number;
+	enableOriErrRetry?: boolean;
+	needSyncAnalyzeError?: boolean;
+	analyzeTimeout?: number;
+	DefinitionDemotePlugin?: any;
+	DASHPlugin?: any;
+	EncryptHlsPlugin?: any;
+	vodLogOpts?: any;
+	logTeaAppId?: number;
+	Mp4EncryptPlayer?: any;
+	autoBitrateOpts?: LiteAutoBitrateConfig;
+	adaptRange?: any;
+	duration?: number;
+	MemoryPlay?: any;
+	AutoplayPlugin?: any;
+	playListPlugin?: any;
+	dynamicwatermark?: any;
+	thumbnail?: LiteThumbnailConfig;
+	progressDot?: LiteProgressDot[];
+	mode?: number;
+	seekedStatus?: "play" | "pause" | "auto";
+}
+export interface LiteSourceConfig<MediaUrl extends LiteMediaUrl = LiteMediaUrl, StreamUrl extends LiteMediaUrl = LiteMediaUrl> {
+	url?: MediaUrl & LiteUrl<MediaUrl>;
+	playList?: Array<LiteStream<StreamUrl>>;
+	getVideoByToken?: LitePlayAuthTokenConfig;
+	urlExpireTimestamp?: number;
+}
+export interface LiteDefinition {
+	definition: string;
+	url: LiteUrl;
+	selected: boolean;
+}
+export interface LiteSubtitleItem {
+	id?: string | number;
+	language?: string | number;
+	label?: string | number;
+	text?: string;
+	url?: string;
+}
+export interface LitePluginInstance {
+	readonly pluginName?: string;
+}
+export interface LitePluginConstructor<Instance extends LitePluginInstance = LitePluginInstance> {
+	readonly pluginName?: string;
+	new (...args: unknown[]): Instance;
+}
+export interface LiteVePlayer {
+	readonly preLoadData: {
+		hit: number;
+		duration?: number;
+		length?: number;
+	};
+	readonly region: string;
+	src: LiteUrl;
+	readonly userRegion: string;
+	changeDefinition(definition: string): void;
+	destroy(): Promise<void>;
+	emit(action: string, payload?: unknown): void;
+	getCurrentPlayerConfig(): LiteDefaultConfig;
+	getDefinitionList(): LiteDefinition[];
+	getLogUserId(): string | undefined;
+	getPlayerInstance(): unknown;
+	getPlugin(pluginName: string): LitePluginInstance | null;
+	getSdkPlugin(name: string): LitePluginInstance | null;
+	getSubtitleList(): LiteSubtitleItem[];
+	hideSubtitle(): void;
+	next<MediaUrl extends LiteMediaUrl, StreamUrl extends LiteMediaUrl>(config: LitePlayerConfig<MediaUrl, StreamUrl>, isNewVideo?: boolean): Promise<void>;
+	off(action: string, func: (...args: unknown[]) => void): void;
+	on(action: string, func: (...args: unknown[]) => void): void;
+	once(action: string, func: (...args: unknown[]) => void): void;
+	playNext<MediaUrl extends LiteMediaUrl, StreamUrl extends LiteMediaUrl>(config: LitePlayerConfig<MediaUrl, StreamUrl>, isNewVideo?: boolean): Promise<unknown>;
+	showSubtitle(): void;
+	switchAuthToken(config: LitePlayAuthTokenConfig, isNewVideo?: boolean): Promise<void>;
+	switchSubtitle(subtitle: {
+		id?: string | number;
+		language?: string | number;
+	}): Promise<void>;
+	switchURL<MediaUrl extends LiteMediaUrl>(url: MediaUrl & LiteUrl<MediaUrl>): Promise<void>;
+	updateAuthToken(config: LitePlayAuthTokenConfig): Promise<void>;
+	updateMediaSource<MediaUrl extends LiteMediaUrl, StreamUrl extends LiteMediaUrl>(source: LiteSourceConfig<MediaUrl, StreamUrl>): Promise<void>;
+}
+type CollectorConstructor = new (name: string) => any;
+export interface LiteVePlayerConstructor {
+	readonly prototype: LiteVePlayer;
+	readonly sdkVersion: string;
+	readonly Events: LiteEvents;
+	readonly Event: LiteEvent;
+	readonly DefinitionDemotePlugin: LitePluginConstructor;
+	readonly MirrorPlugin: LitePluginConstructor;
+	readonly MemoryPlay: LitePluginConstructor;
+	readonly Subtitle: LitePluginConstructor;
+	readonly DynamicWatermarkPlugin: LitePluginConstructor;
+	readonly PlayListPlugin: LitePluginConstructor;
+	readonly getI18N: () => typeof I18N;
+	readonly BasePlugin: typeof import("xgplayer").BasePlugin;
+	readonly Plugin: typeof import("xgplayer").Plugin;
+	readonly Sniffer: typeof import("xgplayer").Sniffer;
+	readonly Util: typeof import("xgplayer").Util;
+	readonly STATE_CLASS: typeof import("xgplayer").STATE_CLASS;
+	readonly I18N: typeof import("xgplayer").I18N;
+	readonly STATES: typeof import("xgplayer").STATES;
+	readonly veStrategy: LiteVeStrategy;
+	readonly ttDramaEnv: LiteTTDramaEnv | null;
+	readonly preloader: LitePreloaderManager | undefined;
+	readonly preloaderStatus: LitePreloaderStatus;
+	new <MediaUrl extends LiteMediaUrl = LiteMediaUrl, StreamUrl extends LiteMediaUrl = LiteMediaUrl>(configs: LitePlayerConfig<MediaUrl, StreamUrl>): LiteVePlayer;
+	prepare(options: LiteStrategyInitOptions): Promise<void>;
+	registerModules(modules: UmdModules): void;
+	setTTDramaEnv(env: LiteTTDramaEnv): void;
+	setPreloadScene(preloadScene: LitePreloadScene, options?: LitePreloadUpdateConfig): void;
+	addPreloadList(list: LitePreloadStream[]): Promise<void>;
+	setPreloadList(list: LitePreloadStream[]): Promise<void>;
+	getAppendVideoUrlTimestamp(): boolean;
+	isMSESupported(): boolean;
+	setAppendVideoUrlTimestamp(enable?: boolean): void;
+	setCollector(Collector?: CollectorConstructor): void;
+	setDebug(enable: boolean): void;
+	setMediaInfoCacheConfig(config: LiteMediaInfoCacheConfig): void;
+	getMediaInfoCacheConfig(): LiteMediaInfoCacheState;
+	clearMediaInfoCache(): void;
+	generateEncryptInfo(unionId: string, streamType: "hls" | "mp4" | "dash"): Promise<LiteEncryptInfo | undefined>;
+}
+declare const LiteVePlayer: LiteVePlayerConstructor;
+export declare const Subtitle: LitePluginConstructor;
+export declare const DynamicWatermarkPlugin: LitePluginConstructor;
+export declare const DefinitionDemotePlugin: LitePluginConstructor;
+export declare const MirrorPlugin: LitePluginConstructor;
+export declare const MemoryPlay: LitePluginConstructor;
+export declare const PlayListPlugin: LitePluginConstructor;
+export declare function getI18N(): typeof I18N;
+export { BasePlugin, Plugin, Sniffer, Util, STATE_CLASS, I18N, STATES, } from "xgplayer";
+export type { IBasePluginOptions, IDefinition, IError, IPluginOptions, IVideoProxy, IXGI18nText, SwitchUrlOptions, } from "xgplayer";
+
+export {
+	LiteVePlayer as default,
+};
+
+export {};