import { NetworkMonitor } from '@byted/network-monitor';
import { IRTCEngine, MediaType, VideoPlayerOption } from '@volcengine/rtc';
import Tea from 'byted-tea-sdk';
import EventEmitter from 'eventemitter3';

declare class RemoteLogger extends EventEmitter {
	private commonParams;
	userId: string;
	startEventTime: any;
	teaLog: Tea | null;
	isDisabled: boolean;
	constructor(options: {
		userId: string;
		channelDomain: string;
		SDKVersion: string;
		disableLogger?: boolean;
	});
	setCommonParams(params: any): void;
	setSingleParam(key: any, value: any): void;
	getCommonParams(): {
		accountId: string;
		volcProduct: "vePhone" | "veGame";
		initSessionId: string;
		sessionId: string;
		uuid: string;
	} | Record<string, never>;
	sendWithDIYName(eventName: any, rawData?: {}): void;
	send(eventName: string, rawData?: {}, oldData?: {}): void;
	beaconSend(eventName: string, rawData?: {}): void;
	destroy(): void;
}
declare class Logger extends RemoteLogger {
	state: any;
	send: any;
	setCommonParams: any;
	isSupportIDB: boolean;
	idb: any;
	private urlQuery;
	constructor(options: any);
	getTime(): string;
	print(level: any, stage: any, prefix: any, messageList: any): void;
	getLocalShowGroup(): {
		logShowFlag: boolean;
		levelList: string[];
		stageList: string[];
	};
	localLog(level: any, stage: any, method: any, messageList: any): boolean;
	localWarnLog(stage: any, method: any, ...messageList: any[]): void;
	localErrorLog(stage: any, method: any, ...messageList: any[]): void;
	localInfoLog(stage: any, method: any, ...messageList: any[]): void;
	localTraceLog(stage: any, method: any, ...messageList: any[]): void;
}
declare function setSdkType(type: string): void;
export declare enum MODE {
	CLOUD_PHONE_GAME = 0,
	CLOUD_PHONE = 1,
	CLOUD_PC = 2
}
export declare enum LOCATION_SERVICE_MODE {
	MODE_AUTO = 0,
	MODE_MANUAL = 1
}
export declare enum ACTION {
	DOWN = 0,
	UP = 1,
	MOVE = 2,
	TOUCH_START = 0,
	TOUCH_END = 1,
	TOUCH_MOVE = 2,
	WHEEL = 8,
	PC_TOUCH_UP = 0,
	PC_TOUCH_DOWN = 1,
	PC_TOUCH_MOVE = 2
}
export declare enum MOUSE_BUTTON {
	LEFT = 0,
	CENTER = 1,
	RIGHT = 2
}
export declare enum KEYCODE {
	KEYCODE_HOME = 3,
	KEYCODE_BACK = 4,
	KEYCODE_MENU = 82,
	KEYCODE_APP_SWITCH = 187
}
export declare const STREAM_TYPE: {
	STREAM_INDEX_MAIN: number;
	STREAM_INDEX_SCREEN: number;
};
export declare const VIDEO_SOURCE_TYPE: {
	VIDEO_SOURCE_TYPE_EXTERNAL: number;
	VIDEO_SOURCE_TYPE_INTERNAL: number;
};
export declare const AUDIO_SOURCE_TYPE: {
	AUDIO_SOURCE_TYPE_EXTERNAL: number;
	AUDIO_SOURCE_TYPE_INTERNAL: number;
};
export declare enum VIDEO_RENDER_MODE {
	CONTAIN = 0,
	FILL = 1,
	COVER = 2
}
declare function setDeviceId(did: string): void;
declare function getDeviceId(): string;
declare class EventStore {
	el: HTMLElement;
	_removeList: {
		name: keyof HTMLElementEventMap;
		fn: any;
	}[];
	setElement(el: HTMLElement): void;
	private getTarget;
	add(name: keyof HTMLElementEventMap | Record<keyof HTMLElementEventMap, any>, fn?: any): void;
	remove(name: string): void;
	clear(): void;
	getChangedTouches(e: TouchEvent): Touch[];
}
declare class TouchIdUnifier {
	private isIOS;
	private idArray;
	private idMap;
	private _nextId;
	touchCancel(): void;
	unite(e: TouchEvent): TouchEvent;
	uniteId(id: string | number, isEnd?: boolean): number;
	private handleTouches;
	private nextId;
	private updateNextId;
	private onTouchEnd;
}
declare class TouchSender {
	private _touchCacheMap;
	touchUnifier: TouchIdUnifier;
	parent: any;
	private _touchDataCache;
	constructor(parent: any);
	private _modifyTouchCache;
	private generateTouchList;
	clearAllTouch(): void;
	get isPCTouch(): boolean;
	private sendTouchList;
	send(touchMessage: any): void;
	private countSendAction;
	private countPCTouchAction;
}
declare class TouchHandler {
	noScaleAndLandscape: boolean;
	noScale: boolean;
	eventStore: EventStore;
	touchSender: TouchSender;
	hasVideoBlackPadding: boolean;
	_player: any;
	mode: number;
	domId: string;
	isPC?: boolean;
	disableInteraction?: boolean;
	enableLocalMouseScroll: boolean;
	disableDefaultTouchEvent: boolean;
	hasMouseScrollVirtualClick: boolean;
	mouseScrollVirtualClickPosition: {
		clientX?: number;
		clientY?: number;
	};
	touchElement: HTMLElement;
	customTouchesList: Record<string, any>;
	keyPressedList: Record<string, string>;
	isMouseDown: boolean;
	podWidth?: number;
	podHeight?: number;
	streamWidth?: number;
	streamHeight?: number;
	scale?: number;
	enableScale: boolean;
	degree?: number;
	rotation?: number;
	localKeyboardHandler: any;
	systemCursorShowStat: boolean;
	systemCursorHiddenVirtualPosition: {
		clientX: number;
		clientY: number;
	};
	_videoRenderMode: number;
	private _isClickFlag?;
	resetMouseScroll: () => void;
	private mouseMoveInterval;
	private mouseMoveLastTriggerTime;
	private mouseMoveCacheData;
	constructor(player: any, { domId, mode, isPC, disableInteraction, enableLocalMouseScroll, localKeyboardHandler, disableDefaultTouchEvent, }: {
		domId: any;
		mode: any;
		isPC?: boolean;
		disableInteraction?: boolean;
		enableLocalMouseScroll?: boolean;
		localKeyboardHandler?: any;
		disableDefaultTouchEvent: any;
	});
	setMouseMoveInterval(interval: number): void;
	setDegree(degree: any): void;
	setRotation(rotation: any): void;
	private _isPEinited;
	pointerMove(e: PointerEvent): void;
	_initEvent(): void;
	setStreamSize({ streamWidth, streamHeight }: {
		streamWidth: any;
		streamHeight: any;
	}): void;
	setContentSize({ width, height, enableScale }: {
		width: any;
		height: any;
		enableScale: any;
	}): void;
	set videoRenderMode(renderMode: number);
	get videoRenderMode(): number;
	updateVideoScale(rtcVideo: any): {
		podWidth: number;
		podHeight: number;
		streamWidth: number;
		streamHeight: number;
		clientWidth: number;
		clientHeight: number;
		scale: number;
		noScale: boolean;
		noScaleAndLandscape?: undefined;
		rotationPodWidth?: undefined;
		rotationPodHeight?: undefined;
		rotationStreamWidth?: undefined;
		rotationStreamHeight?: undefined;
	} | {
		podWidth: number;
		podHeight: number;
		streamWidth: number;
		streamHeight: number;
		clientWidth: number;
		clientHeight: number;
		scale: number;
		noScaleAndLandscape: boolean;
		noScale?: undefined;
		rotationPodWidth?: undefined;
		rotationPodHeight?: undefined;
		rotationStreamWidth?: undefined;
		rotationStreamHeight?: undefined;
	} | {
		rotationPodWidth: number;
		rotationPodHeight: number;
		rotationStreamWidth: number;
		rotationStreamHeight: number;
		clientWidth: number;
		clientHeight: number;
		scale: number;
		podWidth?: undefined;
		podHeight?: undefined;
		streamWidth?: undefined;
		streamHeight?: undefined;
		noScale?: undefined;
		noScaleAndLandscape?: undefined;
	};
	contextListener(e: any): void;
	touchStart(event: any): void;
	touchEnd(event: any): void;
	touchMove(event: any): void;
	sendTouchMessage(touchMessage: any): void;
	mouseDown(event: any): void;
	mouseMove(event: any): void;
	mouseUp(event: any): void;
	resetMouseScrollVirtualClick(): void;
	mouseConvert(event: any, action: any, pointerId?: string): {
		x: number;
		y: number;
	};
	wheelEvent(event: any): void;
	mouseConvertPCPB({ event, action, width, height, offsetLeft, offsetTop }: {
		event: any;
		action: any;
		width: any;
		height: any;
		offsetLeft: any;
		offsetTop: any;
	}): {
		x: number;
		y: number;
	};
	coordinateScaleAndRotate({ width, height, targetx, targety, podWidth, podHeight }: {
		width: any;
		height: any;
		targetx: any;
		targety: any;
		podWidth: any;
		podHeight: any;
	}): {
		x: number;
		y: number;
	};
	keydown(event: any, force?: boolean): void;
	keyup(event: any, force?: boolean): void;
	pasteEvent(event: any): void;
	_firstClickPlayAudio(): void;
	destroy(): void;
}
declare class KeyboardDisableHandler {
	player: any;
	_enabled: boolean;
	constructor(player: any);
	setEnabled(enabled: any): void;
	handleResponse(msg: any): void;
	setKeyboardEnable(enable: any): Promise<unknown>;
	getKeyboardEnable(): boolean;
}
declare class NetworkHandler {
	private player;
	private mIsVideoPlaying;
	private mIsAudioPlaying;
	private mHasFirstVideoFrame;
	private mNetworkDown;
	private visibilityState;
	private networkStatus;
	queue: any[];
	static NetworkQuality: {
		VERY_BAD: number;
		BAD: number;
		GOOD: number;
		DOWN: number;
		UNKNOWN: number;
		EXCELLENT: number;
		POOR: number;
	};
	constructor(player: any);
	_receiveStat(stat: any): number;
}
declare function usePlugin(plugin: any): void;
declare function isSupportedStatic(): Promise<boolean>;
declare function orientationChange(onchange: (orientation: 0 | 90 | -90, reason: "orientationchange" | "resize") => void): () => void;
declare class PageLifeHandler extends BaseHandler {
	visible: boolean;
	online: boolean;
	networkLevel: number;
	private _listeners;
	networkMonitor: NetworkMonitor;
	init(): void;
	initNetworkMonitor(): void;
	onlineChange(bool: boolean): void;
	destroy(): void;
}
declare class QueueHandler extends BaseHandler {
	queuePriority: number;
	interval: number;
	timer: any;
	body: any;
	private isFirst;
	getStartSize: () => any;
	clearState(): void;
	setQueuePriority(priority: number): void;
	get needUseQueue(): boolean;
	gameStart(body: any, getStartSize: any): Promise<any>;
	private loopQueryQueue;
	private innerGameStart;
	private fetchQueryQueue;
	private checkQueueList;
	private addUserQueue;
	destroy(): void;
}
declare class MessageHandler extends BaseHandler {
}
declare class StuckMonitorHandler extends BaseHandler {
	static handlerName: string;
	private decodeFPS;
	private receiveFPS;
	private listener;
	init(): void;
	destroy(): void;
}
declare class VideoStreamProfileHandler extends BaseHandler {
	switchVideoStreamProfile(id: number): Promise<{
		result: number;
		reason: string;
		before: string;
		after: string;
	}>;
	getVideoStreamProfile(): Promise<{
		result: number;
		reason: string;
		before: string;
		after: string;
	}>;
	private _handleVideoStreamProfileEvent;
}
declare class AutoRecycleTimeHandler extends BaseHandler {
	private _autoRecycleTime;
	setAutoRecycleTime(duration: number): Promise<void>;
	getAutoRecycleTime(): Promise<{
		time: number;
	}>;
}
declare class ScreenShotHandler extends BaseHandler {
	private _sequence;
	private _loggerSend;
	screenShot(isSavedOnPod?: boolean): Promise<{
		result: any;
		savePath: any;
		message: string;
		downloadUrl: string;
	}>;
	screenShotLocal(autoDownload: boolean): void;
	private downloadImge;
}
declare class PodAppHandler extends BaseHandler {
	commandType: number[];
	handleMessage(msg: {
		command: number;
		data: any;
	}): boolean;
	private handleCrash;
	private handleLaunch;
}
declare class PodControlHandler extends BaseHandler {
	commandType: number[];
	enableMicInnerRecord(enable: boolean): Promise<unknown>;
	handleMessage(msg: {
		command: number;
		data: {
			status?: number;
		};
	}): boolean;
}
declare class BackgroundHandler extends BaseHandler {
	commandType: number[];
	handleMessage(decodedMessage: {
		command: number;
		data: any;
	}): boolean;
	switchBackground(on: boolean): Promise<any>;
	private handleBackgroundEvent;
}
declare class StartWithFrameworkHandler extends BaseHandler {
	commandType: number[];
	handleMessage(msg: {
		command: number;
		data: any;
	}): boolean;
}
declare abstract class HandleManagerBase {
	PageLifeHandler: PageLifeHandler;
	QueueHandler: QueueHandler;
	MessageHandler: MessageHandler;
	ConfigHandler: ConfigHandler;
	StuckMonitorHandler: StuckMonitorHandler;
	VideoStreamProfileHandler: VideoStreamProfileHandler;
	AutoRecycleTimeHandler: AutoRecycleTimeHandler;
	ScreenShotHandler: ScreenShotHandler;
	PodAppHandler: PodAppHandler;
	PodControlHandler: PodControlHandler;
	BackgroundHandler: BackgroundHandler;
	StartWithFrameworkHandler: StartWithFrameworkHandler;
	FullScreenHandler: FullScreenHandler;
}
declare function useHandler(handler: any): boolean;
declare class HandleManager extends HandleManagerBase {
	[prop: string]: any;
	private _keys;
	constructor(player: Player);
	initHandlers(): void;
	handleMessage(decodedMessage: {
		command: number;
		data: any;
	}): boolean;
	destroy(): void;
}
export interface IMessageReturnOptions {
	message: any;
	conditionFn: (resp: any) => boolean;
	timeout?: number;
}
declare class BaseHandler implements IConfigHelper {
	static handlerName?: string;
	player: Player;
	manager: HandleManager;
	commandType?: number[];
	private _localLog;
	constructor(player: Player, manager: HandleManager);
	get isPhone(): boolean;
	get isPCGame(): boolean;
	init(): void;
	destroy(): void;
	handleMessage(decodedMessage: {
		command: number;
		data: any;
	}): boolean;
	fetchBase(data: any): Promise<any>;
	fetchInnerApi(data: any): Promise<any>;
	onMessage(decodedMessage: {
		type: number;
		subtype: number;
		msg: any;
	}): void;
	on(name: string, fn: (v: any) => void): void;
	off(name: string, fn: (v: any) => void): void;
	emit(name: string, data?: any): void;
	log(name: string, data?: Record<string, any>): void;
	beaconLog(name: string, data?: Record<string, any>): void;
	getLogParams(): {
		commonParams: {
			accountId: string;
			volcProduct: "vePhone" | "veGame";
			initSessionId: string;
			sessionId: string;
			uuid: string;
		} | Record<string, never>;
		initConfig: {
			userId: string;
			channelDomain: string;
			SDKVersion: string;
		};
	};
	print(...args: any[]): void;
	printTraceLog(...args: any[]): void;
	sendMessage(customMessage: Record<string, any> | ArrayBufferLike): Promise<any>;
	sendPBMessage(message: ArrayBufferLike): Promise<any>;
	sendJsonMessage(message: any): Promise<any>;
	sendMessageBase(message: string | any, isBinary?: boolean): Promise<unknown>;
	sendMessageWithReturn({ message, conditionFn, timeout }: {
		message: any;
		conditionFn: (resp: any) => boolean;
		timeout?: number;
	}): Promise<any>;
	setLogInfo(key: string | Record<string, any>, value?: any): void;
	get config(): ICGConfig;
	get store(): ICGStore;
	getConfig<T extends keyof ICGConfig>(key: T): ICGConfig[T];
	setConfig<T extends keyof ICGConfig>(key: T, value: ICGConfig[T]): ICGConfig[T];
	getStore<T extends keyof ICGStore>(key: T): ICGStore[T];
	setStore<T extends keyof ICGStore>(key: T, value: ICGStore[T]): ICGStore[T];
	assignConfig(config?: ICGConfig): void;
	assignStore(store?: ICGStore): void;
	get renderEle(): HTMLVideoElement;
}
export interface ICGConfig {
	shouldPlayWhenPause?: boolean;
	enableScreenRotationTouch?: boolean;
	disableNetworkMonitor?: boolean;
	expectedIdc?: string;
	enableVirtualKeyboard?: boolean;
	needRotateVirtualKeyboard?: boolean;
	disableWebTsABTest?: boolean;
	customSDKVersion?: string;
	mouseAndTouch?: "auto" | "mouse" | "touch" | "both";
}
export interface ICGStore {
	gameHost?: string;
	accountId?: string;
	enableLocalKeyboard?: boolean;
	userId?: string;
	mode?: number;
	isPC?: boolean;
	queuePriority?: number;
	sessionMode?: number;
	videoStreamProfileId?: number;
	gameId?: string;
	productId?: string;
	token?: STSToken;
	rotation?: string;
	isScreenLock?: boolean;
	reservedId?: string;
	deviceId?: string;
	sessionId?: string;
	skey?: string;
	roundId?: string;
	expectedIdc?: string;
	isPcPortraitGame?: boolean;
	useWebts?: boolean;
	podId?: string;
	roomId?: string;
	remoteWindowSize?: {
		width?: number;
		height?: number;
	};
	mediaProvider?: string;
	enableRemoteIme?: boolean;
}
export interface IConfigHelper {
	get config(): ICGConfig;
	get store(): ICGStore;
	getConfig: <T extends keyof ICGConfig>(key: T) => ICGConfig[T];
	setConfig: <T extends keyof ICGConfig>(key: T, value: ICGConfig[T]) => ICGConfig[T];
	getStore: <T extends keyof ICGStore>(key: T) => ICGStore[T];
	setStore: <T extends keyof ICGStore>(key: T, value: ICGStore[T]) => ICGStore[T];
	assignConfig: (config?: ICGConfig) => void;
	assignStore: (store?: ICGStore) => void;
}
declare class ConfigHandler extends BaseHandler {
	static handlerName: string;
	_config: ICGConfig;
	private _store;
	destroy(): void;
	get config(): ICGConfig;
	get store(): ICGStore;
	getConfig<T extends keyof ICGConfig>(key: T): ICGConfig[T];
	setConfig<T extends keyof ICGConfig>(key: T, value: ICGConfig[T]): ICGConfig[T];
	assignConfig(config?: ICGConfig): void;
	getStore<T extends keyof ICGStore>(key: T): ICGStore[T];
	setStore<T extends keyof ICGStore>(key: T, value: ICGStore[T]): ICGStore[T];
	assignStore(store?: ICGStore): void;
}
export interface CloudCoreConfig {
	userId?: string;
	domId: string;
	accountId: string;
	isBatchStream?: boolean;
	region?: string;
	isPC?: boolean;
	containerDomId?: string;
	isVePhone?: boolean;
	mode?: number;
	disableInteraction?: boolean;
	getResourceHost?: string;
	gameHost?: string;
	phoneHost?: string;
	isDebug?: boolean;
	debug?: boolean;
	enableSyncClipboard?: boolean;
	enableLocationService?: boolean;
	enableLocalKeyboard?: boolean;
	enableRemoteIme?: boolean;
	enableLocalMouseScroll?: boolean;
	disableAudioInjection?: boolean;
	disableDefaultTouchEvent?: boolean;
	needConnectFileChannel?: boolean;
	mediaProvider?: string;
	isSocketSupport?: boolean;
	keyCodeList?: number[];
	podSettings?: {
		type?: 0 | 1 | 2;
		max_pcu?: number;
		role?: 0 | 1;
	};
	customLocalKeyboardInputId?: string;
	useCustomLocalKeyboardInput?: boolean;
	config?: ICGConfig;
	isClusterControl?: boolean;
	masterId?: string;
	isEventSyncInOtherProcess?: boolean;
	disableLogger?: boolean;
	openAutoRotate?: boolean;
}
export interface STSToken {
	AccessKeyID: string;
	SecretAccessKey: string;
	ExpiredTime: string;
	CurrentTime: string;
	SessionToken?: string;
}
export interface CoreStartConfig {
	productId: string;
	mute?: boolean;
	token: STSToken;
	roundId?: string;
	videoStreamProfileId?: number;
	planId?: string;
	rotation?: string;
	isScreenLock?: boolean;
	userTag?: string;
	extra?: Record<string, string | boolean>;
	accountId: string;
	podId: string;
	applicationId?: string;
	reservedId?: string;
	isReset?: boolean;
	audioAutoPlay?: boolean;
	mediaProvider?: "bytertc" | "llama-webrtc" | string;
	autoRecycleTime?: number;
	waitTime?: number;
	userProfilePathList?: string[];
	remoteLocationMock: {
		latitude: number;
		longitude: number;
	};
	enableFullScreen?: boolean;
	systemCursorShowStatManual?: boolean;
	keyboardEnable?: boolean;
	videoRenderMode?: number;
	remoteWindowSize?: {
		width: number;
		height: number;
	};
	sessionMode?: number;
	isPcPortraitGame?: boolean;
	idleReminderDuration?: number;
	isSimpleFetch?: boolean;
	masterId?: string;
	expireTime?: number;
	openAutoRotate?: boolean;
	pluginPath?: string;
	enablePreJoin?: boolean;
	enableUserIdAuth?: boolean;
	enableRemoteIme?: boolean;
	muteAudio?: boolean;
}
export interface IStartStreamingEngineOptions {
	engineType: "bytertc" | "llama-webrtc" | "llama";
	roomId: string;
	podUserId: string;
	rtcAppId: string;
	width: number;
	height: number;
	mute?: boolean;
	isScreenLock?: boolean;
	token: STSToken | string | unknown;
	videoRenderMode?: number;
	rotation?: string | number;
	startTime?: number;
	extra?: Record<string, string>;
	gameType?: string;
	expectedIDC?: string;
	preJoinRoomData?: string;
	retry?: boolean;
}
declare class HandlerCore extends EventEmitter implements IConfigHelper {
	static useHandler: typeof useHandler;
	handlers: HandleManager;
	createHandlers(player: Player): void;
	initHandlers(): void;
	get config(): ICGConfig;
	get store(): ICGStore;
	getConfig<T extends keyof ICGConfig>(key: T): ICGConfig[T];
	setConfig<T extends keyof ICGConfig>(key: T, value: ICGConfig[T]): ICGConfig[T];
	getStore<T extends keyof ICGStore>(key: T): ICGStore[T];
	setStore<T extends keyof ICGStore>(key: T, value: ICGStore[T]): ICGStore[T];
	assignConfig(config?: ICGConfig): void;
	assignStore(store?: ICGStore): void;
}
declare enum PodStatus {
	StreamStatusIdle = 256,
	StreamStatusUsed = 768,
	StreamStatusStarting = 769,
	StreamStatusRunning = 770,
	StreamStatusStreaming = 771,
	StreamStatusAppFrameworkException = 816,
	StreamStatusDestroy = 784,
	StreamStatusDestroyTimeout = 785,
	StreamStatusDestroySilence = 786,
	StreamStatusDestroyLackImage = 787,
	StreamStatusDestroyStartFailed = 788,
	StreamStatusDestroyRtcError = 789,
	StreamStatusDestroyAppFrameworkLackImage = 790,
	StreamStatusFault = 1024,
	StreamStatusAppFwStartFailed = 1025,
	StreamStatusStartFailed = 1026,
	StreamStatusCrash = 1027,
	StreamStatusStreamTimeout = 1028,
	StreamStatusCheckFailed = 1030,
	StreamStatusInstanceOffline = 1031,
	StreamStatusGameExit = 1032,
	StreamStatusPowerOff = 1280,
	StreamStatusReboot = 1281,
	StreamStatusPodStop = 1282,
	StreamStatusMask = 3840
}
declare enum MediaType {
	None = 0,
	Audio = 1,
	Video = 2,
	Both = 3
}
export interface PlayerOption {
	renderDom?: string | HTMLElement;
	renderMode?: VideoRenderMode;
	rotation?: number;
	muted?: boolean;
}
declare enum VideoRenderMode {
	Cover = 0,
	Contain = 1,
	Fill = 2
}
declare enum ConnectionState {
	Init = "Init",
	Connecting = "Connecting",
	Connected = "Connected",
	Reconnecting = "Reconnecting",
	Reconnected = "Reconnected",
	Disconnected = "Disconnected"
}
export interface RemoteMediaParams {
	video?: {
		width: number;
		height: number;
	};
	audio?: {
		sampleRate?: number;
		channels?: number;
	};
}
export interface RemoteStreamStats {
	audioStats?: RemoteAudioStats;
	videoStats: RemoteVideoStats;
}
export interface RemoteAudioStats {
	audioLossRate: number;
	receivedKBitrate: number;
	receivedbps: number;
	packetsReceived: number;
	stallCount?: number;
	stallDuration?: number;
	statsInterval: number;
	rtt: number;
	jitterBufferDelay: number;
	numChannels: number;
	receivedSampleRate: number;
	concealedSamples: number;
	concealmentEvent: number;
	codecType?: string;
	fecPacketsReceived?: number;
	jitterBufferMinimumDelay?: number;
	jitterBufferTargetDelay?: number;
	nackCount?: number;
}
export interface RemoteVideoStats {
	width: number;
	height: number;
	videoLossRate: number;
	receivedKBitrate: number;
	receivedbps: number;
	decoderOutputFrameRate: number;
	receivedFrameRate: number;
	stallCount500ms?: number;
	stallDuration500ms?: number;
	stallRate500ms?: number;
	stallDuration100ms?: number;
	stallCount100ms?: number;
	stallRate100ms?: number;
	statsInterval: number;
	rtt: number;
	codecType: "H264" | "VP8";
	jitterBufferDelay?: number;
	packetsReceived?: number;
	avgDecodeDelay?: number;
	keyFramesDecoded?: number;
	framesDropped?: number;
	firCount?: number;
	nackCount?: number;
	pliCount?: number;
	jitterBufferMinimumDelay?: number;
	jitterBufferTargetDelay?: number;
	e2eDelay?: number;
	jitter?: number;
	processingDelay?: number;
	assemblyFrameDelay?: number;
	interFrameDelay?: number;
	codecId?: string;
	decoderImplementation?: string;
	renderFrameRate?: number;
	jitterBufferEmittedCount?: number;
}
export interface VideoEncoderConfig {
	width: number;
	height: number;
	frameRate: number;
	maxKbps: number;
}
declare enum EngineEventsTypes {
	onConnectionStateChanged = "onConnectionStateChanged",
	onUserJoined = "onUserJoined",
	onUserLeave = "onUserLeave",
	onUserPublishStream = "onUserPublishStream",
	onUserUnpublishStream = "onUserUnpublishStream",
	onFirstVideoFrameRendered = "onFirstVideoFrameRendered",
	onAutoplayFailed = "onAutoplayFailed",
	onPlayerEvent = "onPlayerEvent",
	onRemoteStreamStats = "onRemoteStreamStats",
	onRemoteMediaParamsChanged = "onRemoteMediaParamsChanged",
	onSEIMessageReceived = "onSEIMessageReceived",
	onUserMessageReceived = "onUserMessageReceived",
	onUserBinaryMessageReceived = "onUserBinaryMessageReceived",
	onLogReport = "onLogReport",
	onError = "onError",
	onWarning = "onWarning"
}
export interface IEngineEvents {
	[EngineEventsTypes.onUserLeave]: (params: {
		userId: string;
		reason?: any;
	}) => void;
	[EngineEventsTypes.onUserJoined]: (params: {
		userId: string;
	}) => void;
	[EngineEventsTypes.onUserPublishStream]: (params: {
		mediaType: MediaType;
	}) => void;
	[EngineEventsTypes.onFirstVideoFrameRendered]: () => void;
	[EngineEventsTypes.onAutoplayFailed]: (params: {
		kind: string;
	}) => void;
	[EngineEventsTypes.onPlayerEvent]: (params: {
		eventName: string;
		type: string;
	}) => void;
	[EngineEventsTypes.onUserMessageReceived]: (message: string) => void;
	[EngineEventsTypes.onUserBinaryMessageReceived]: (message: ArrayBuffer) => void;
	[EngineEventsTypes.onSEIMessageReceived]: (message: ArrayBuffer) => void;
	[EngineEventsTypes.onRemoteMediaParamsChanged]: (mediaParams: RemoteMediaParams) => void;
	[EngineEventsTypes.onRemoteStreamStats]: (stats: RemoteStreamStats) => void;
	[EngineEventsTypes.onConnectionStateChanged]: (params: {
		state: ConnectionState;
		reason?: string;
	}) => void;
	[EngineEventsTypes.onLogReport]: (params: any) => void;
	[EngineEventsTypes.onError]: (error: {
		code: number;
		message: string;
	}) => void;
	[EngineEventsTypes.onWarning]: (error: {
		code: number;
		message: string;
	}) => void;
}
export interface IEngine extends EventEmitter<IEngineEvents> {
	joinRoom: () => Promise<void>;
	leaveRoom: () => Promise<void>;
	subscribeStream: (mediaType: MediaType) => Promise<void>;
	unsubscribeStream: (mediaType: MediaType) => Promise<void>;
	setRemotePlayer: (videoPlayerOption: PlayerOption) => any;
	sendUserMessage: (message: string) => Promise<void>;
	sendUserBinaryMessage: (message: ArrayBuffer) => Promise<void>;
	sendSEIMessage: (message: ArrayBuffer | string, repeatCount?: number) => void;
	destroy: () => void;
	play: (mediaType?: MediaType) => void;
	publishStream: (mediaType: MediaType, stream?: MediaStream) => Promise<void>;
	unpublishStream: (mediaType: MediaType) => Promise<void>;
	setVideoEncoderConfig: (config: VideoEncoderConfig) => Promise<void>;
}
declare enum StreamType {
	Audio = 1,
	Video = 2,
	Both = 3
}
export interface IEngineStartOptions {
	roomId: string;
	token: any;
	podUserId: string;
	rtcAppId: string;
	width: number;
	height: number;
	videoRenderMode?: any;
	disableAudioInjection?: boolean;
	mute?: boolean;
	extra?: any;
}
declare abstract class Engine extends EventEmitter {
	abstract start(options: IEngineStartOptions): Promise<{
		width: number;
		height: number;
	} | unknown>;
	abstract stop(isKickedByServer?: boolean): Promise<any>;
	supportH265?: () => Promise<boolean>;
	abstract publishStream(streamType: StreamType, track: MediaStreamTrack): Promise<boolean>;
	abstract unPublishStream(streamType: StreamType): Promise<boolean>;
	abstract muteStream(muteOptions: {
		video?: boolean;
		audio?: boolean;
	}): Promise<void>;
	abstract sendMessage(message: string | ArrayBufferLike, isBinary: boolean): Promise<unknown>;
	abstract sendSEIMessage(message: any, repeatCount: number): void;
	abstract setVideoEncoderConfig(config: any): Promise<void>;
	abstract getConnectionState(): string;
	abstract play(reload?: boolean): Promise<void>;
	abstract pauseOrResume(pause: boolean): void;
	abstract updateToken(token: string): Promise<void>;
	abstract getStats(): Promise<any>;
	abstract setAudioPlaybackDevice(deviceId: string): Promise<void>;
	abstract destroy(): void;
	abstract updateVideoRenderMode(mode: VIDEO_RENDER_MODE): void;
	abstract isAudioMuted(): boolean;
	abstract isVideoMuted(): boolean;
	abstract setAudioMute(mute: boolean): void;
	abstract get isReady(): boolean;
	abstract get audioDom(): HTMLAudioElement;
	status: "start" | "playing" | "stop";
	renderEle: HTMLVideoElement;
	setVolume(volume: number): void;
	getVolume(): number;
}
declare class LlamaWebRTCEngine extends Engine {
	private _player;
	client: IEngine;
	renderEle: HTMLVideoElement;
	audioEle: HTMLAudioElement;
	private _connectionState;
	private _logger;
	private _podUserId;
	private _audioPlayer;
	private _videoPlayer;
	private _stats;
	private $container;
	private _videoRenderMode;
	private _startTime;
	private _startMute;
	private _streamState;
	private _subState;
	private _pubState;
	private _invisible;
	private _connectTimeout;
	private _connectTimer;
	private _startResolve;
	private _startReject;
	static EngineVersion(): string;
	static supported(): Promise<boolean>;
	constructor(_player: Player, config: IEngineConfig);
	private _onVisibilityChange;
	private _initEvents;
	private onFirstVideoFrameRendered;
	private onConnectionStateChanged;
	private _sendStartUp;
	start(options: IEngineStartOptions): Promise<unknown>;
	get isReady(): boolean;
	stop(isKickedByServer: boolean): Promise<void>;
	private _peerLeave;
	sendMessage(message: string | ArrayBuffer, binary?: boolean): Promise<void>;
	getConnectionState(): string;
	play(reload?: boolean): Promise<void>;
	isAudioMuted(): boolean;
	isVideoMuted(): boolean;
	setAudioMute(mute: boolean): void;
	muteStream(mute: {
		audio?: boolean;
		video?: boolean;
	}): Promise<void>;
	updateVideoRenderMode(mode: number): void;
	pauseOrResume(pause: boolean): Promise<void>;
	getStats(): Promise<{}>;
	publishStream(type: StreamType, track?: MediaStreamTrack): Promise<boolean>;
	unPublishStream(type: StreamType): Promise<boolean>;
	replaceVideoTrack(track: MediaStreamTrack): Promise<void>;
	replaceAudioTrack(track: MediaStreamTrack): Promise<void>;
	sendSEIMessage(message: any, repeatCount: number): void;
	setVideoEncoderConfig(config: any): Promise<void>;
	updateToken(token: string): Promise<void>;
	private onLlamaLog;
	private onRemoteStreamStats;
	setAudioPlaybackDevice(deviceId: string): any;
	destroy(): void;
	get audioDom(): HTMLAudioElement;
}
declare class ByteRTCEngine extends Engine {
	isRTC: boolean;
	_userJoined: boolean;
	audioEle?: HTMLAudioElement;
	renderEle: HTMLVideoElement;
	_client: IRTCEngine;
	private _player;
	private _logger;
	private _userId;
	private _containerDomId;
	private _podUserId?;
	private _remoteStream?;
	private _mute?;
	private _startMute?;
	private _reconnectTime?;
	private _sdkType?;
	private _expectedIDC?;
	private _muteState;
	private _isAudioPublishStream;
	private _isVideoPublishStream;
	private _hasEmitAudioAutoWarning?;
	private _canEmitReconnectedEvent?;
	private _hasAddVisibilityChangeListener?;
	status: "start" | "playing" | "stop";
	private _remoteUsers?;
	private _visibilityCallback?;
	private _invisible;
	private _scaleParams;
	private _remotePlayerDom;
	private isPlaying?;
	private _connectState?;
	private _stats?;
	private _reconnectInterId?;
	private _hasInvisible?;
	private _joinRoomTimeout;
	private _waitPodJoinTime;
	private _waitPodJoinTimer;
	private streamIndex;
	private videoSourceType;
	private audioSouceType;
	static setDeviceId(did: string): void;
	static EngineVersion(): string;
	constructor(player: Player, options: IEngineConfig);
	start({ roomId, token, podUserId, rtcAppId, width, height, mute, videoRenderMode, disableAudioInjection, retry, }: IEngineStartOptions): Promise<{
		width: string;
		height: string;
		streamWidth: string | number;
		streamHeight: string | number;
	}>;
	updateToken(token: string): Promise<void>;
	_initMediaDomProps(video: any, audio: any): void;
	_joinRoom(options: any): Promise<unknown>;
	_peerLeave({ errorCode, message, originalErrorCode, originalMessage }: {
		errorCode: any;
		message: any;
		originalErrorCode?: string;
		originalMessage?: string;
	}): void;
	stop(isKickedByServer: boolean): Promise<unknown>;
	sendMessage(message: any, isBinary: any): Promise<unknown>;
	sendSEIMessage(message: any, repeatCount: number): void;
	initStats(): void;
	getStats(): Promise<{
		accessDelay: number;
		videoReceivedPacketsLostRate: number;
		videoReceivedBitrate: number;
		videoReceivedFrameRate: number;
		videoReceivedResolutionHeight: number;
		videoReceivedResolutionWidth: number;
	}>;
	connectionStateMap(e: any): void;
	saveVisibleToHiddenStats(): void;
	restoreVisibleToHiddenStats(): void;
	getConnectionState(): string;
	play(reload?: boolean): Promise<void>;
	setAudioMute(mute: boolean): void;
	isAudioMuted(): boolean;
	muteStream(mute: {
		audio?: boolean;
		video?: boolean;
	}): Promise<void>;
	isVideoMuted(): boolean;
	setVideoMute(mute: any): void;
	unsubscribeStream(mediaType: MediaType): Promise<void>;
	subscribeStream(mediaType: MediaType): Promise<void>;
	pauseOrResume(isPause?: boolean): Promise<void>;
	_retryIsTimeOut(retry: any): void;
	_streamStop(): void;
	_removeClientListener(): void;
	_reconnect(time: any): void;
	_cancelReconnect(): void;
	publishStream(streamType: StreamType, track: MediaStreamTrack): Promise<boolean>;
	unPublishStream(streamType: StreamType): Promise<boolean>;
	replaceVideoTrack(track: MediaStreamTrack): Promise<void>;
	replaceAudioTrack(track: MediaStreamTrack): Promise<void>;
	updateVideoRenderMode(videoRenderMode: any): void;
	set reconnectTime(time: number);
	get reconnectTime(): number;
	get remoteStream(): any;
	get isReady(): boolean;
	destroy(): void;
	private initPauseDetect;
	setVideoEncoderConfig(config: any): Promise<void>;
	setAudioPlaybackDevice(deviceId: string): Promise<void>;
	get audioDom(): HTMLAudioElement;
}
declare enum StreamType {
	Audio = 1,
	Video = 2,
	Both = 3
}
export interface IEngineConfig {
	engineType: "bytertc" | "llama-webrtc" | "llama";
	userId: string;
	containerDomId: string;
	configServerHost?: string;
	sdkType?: string;
	expectedIDC?: string;
}
export interface IEngineStartOptions {
	roomId: string;
	token: any;
	podUserId: string;
	rtcAppId: string;
	width: number;
	height: number;
	videoRenderMode?: any;
	disableAudioInjection?: boolean;
	mute?: boolean;
	extra?: Record<string, any>;
	retry?: boolean;
}
declare class StreamingEngine extends EventEmitter {
	private player;
	type: "bytertc" | "llama-webrtc" | "llama";
	fps: number;
	reconnectTime: number;
	_engine: ByteRTCEngine | LlamaWebRTCEngine;
	static GetVersion(): {
		bytertc: string;
		"llama-webrtc": string;
	};
	constructor(player: Player, options: IEngineConfig);
	private init;
	start(options: IEngineStartOptions): Promise<unknown>;
	setVolume(volume: number): void;
	getVolume(): number;
	stop(isKickedByServer: boolean): Promise<unknown>;
	play(reload?: boolean): Promise<void>;
	sendMessage(message: string | ArrayBufferLike, isBinary?: boolean): Promise<unknown>;
	setVideoEncoderConfig(config: any): Promise<void>;
	sendSEIMessage(message: any, repeatCount: number): void;
	publishStream(type: StreamType, track: MediaStreamTrack): Promise<boolean>;
	unPublishStream(type: StreamType): Promise<boolean>;
	setAudioMute(mute: boolean): void;
	muteStream(muteOptions: {
		video?: boolean;
		audio?: boolean;
	}): Promise<void>;
	isAudioMuted(): boolean;
	isVideoMuted(): boolean;
	updateToken(token: string): Promise<void>;
	getStats(): Promise<{}>;
	getConnectionState(): string;
	setAudioPlaybackDevice(deviceId: string): any;
	pauseOrResume(pasuse: boolean): Promise<void>;
	updateVideoRenderMode(videoRenderMode: VIDEO_RENDER_MODE): void;
	destroy(): void;
	replaceVideoTrack(track: MediaStreamTrack): Promise<void>;
	get status(): "playing" | "start" | "stop";
	get isReady(): boolean;
	get renderEle(): HTMLVideoElement;
	get audioDom(): HTMLAudioElement;
}
declare class RTSEngine extends EventEmitter {
	_client?: IRTCEngine;
	private _logger;
	private _userId;
	private _remoteUsers;
	private _player;
	_roomId: any;
	private _skey;
	private _parentPodId2RoomId;
	static setDeviceId(did: string): void;
	constructor(player: any, options: any);
	start({ roomId, token, appId, }: {
		roomId: any;
		token: any;
		appId: any;
	}): Promise<{
		width: string;
		height: string;
		streamWidth: string | number;
		streamHeight: string | number;
	}>;
	_joinRoom(options: any): Promise<unknown>;
	stop(): Promise<unknown>;
	sendRoomMessage(message: any): Promise<void>;
	sendUserMessage(to: any, message: any): Promise<void>;
	_removeClientListener(): void;
	destroy(): void;
}
export interface IEventType {
	token: STSToken;
	productId: string;
	controlledPodIdList: string[];
	enableForce: boolean;
	masterPodId?: string;
	phoneHost?: string;
}
declare enum EventSyncStatus {
	Idle = 0,
	Starting = 1,
	Started = 2,
	Stopping = 3,
	Error = 4
}
export interface IEventSyncConfig {
	podExpireTime: {
		podId: string;
		expireTime: number;
	}[];
}
declare class BatchEventSyncHandler {
	private _player;
	private _logger;
	private options;
	private rtsRoomList;
	clientList: RTSEngine[];
	private _status;
	private _roomIdMap;
	private _roomId2Client;
	private _podId2RoomId;
	constructor(player: any);
	prepare(info: Omit<IEventType, "userId">): void;
	startEventSync(config?: IEventSyncConfig): Promise<never>;
	stopEventSync(): void;
	updateControlPodList(podList: string[]): void;
	setMasterByPodId(podId: string): void;
	private createAndJoinRtsRoom;
	private initRTSClient;
	getEventSyncStatus(): EventSyncStatus;
	getMasterId(): any;
	sendRtsRoomMessage(message: Record<string, any>): void;
	private _sendp2pMessage;
	sendImeMessage(message: string, podId: string): Promise<void>;
	sendClipBoardMessage(message: string, podId: string): Promise<void>;
	onReceiveRtsMessage(roomId: string, userId: string, message: string): void;
	updateExpireTime(expireTimeConfig: {
		podId: string;
		expireTime: number;
	}[]): Promise<never>;
	private _pollingTaskStatus;
}
declare class MediaDeviceHandler {
	private _logger;
	private _player;
	private audioInputDevice;
	private audioOutputDevice;
	private videoInputDevice;
	private deviceMap;
	private virtualDevicesList;
	constructor(player: Player);
	init(): void;
	private deviceChangeListener;
	private updateDevicesList;
	getAudioPlaybackDevice(): string;
	setAudioPlaybackDevice(deviceId: string): void;
	getAudioPlaybackDeviceList(): Promise<MediaDeviceInfo[]>;
	getAudioCaptureDevice(): string;
	getAudioCaptureDeviceList(): Promise<MediaDeviceInfo[]>;
	setAudioCaptureDevice(deviceId: string): Promise<void>;
	getVideoCaptureDevice(): string;
	getVideoCaptureDeviceList(): Promise<MediaDeviceInfo[]>;
	setVideoCaptureDevice(deviceId: string): Promise<void>;
	setVideoCaptureConfig(config: any): Promise<void>;
	destroy(): void;
}
export interface ControlState {
	userId: string;
	enable: boolean;
}
export interface ControlEventResult {
	code: 0 | -1;
	msg?: string;
	data?: ControlState;
}
declare class Player extends HandlerCore {
	static MODE: typeof MODE;
	static ACTION: typeof ACTION;
	static KEYCODE: typeof KEYCODE;
	static MOUSE_BUTTON: typeof MOUSE_BUTTON;
	static NETWORK_QUALITY: {
		VERY_BAD: number;
		BAD: number;
		GOOD: number;
		DOWN: number;
		UNKNOWN: number;
		EXCELLENT: number;
		POOR: number;
	};
	static use: typeof usePlugin;
	static plugins: any[];
	static setSdkType: typeof setSdkType;
	static onOrientationChange: typeof orientationChange;
	static getDeviceId: typeof getDeviceId;
	static setDeviceId: typeof setDeviceId;
	static __RTC_BLACK_LIST__: RegExp[];
	options: CloudCoreConfig;
	userId: string;
	domId: string;
	customLocalKeyboardInputId: string;
	useCustomLocalKeyboardInput: boolean;
	region: string;
	mode: number;
	isVePhone?: boolean;
	isPC?: boolean;
	disableInteraction?: boolean;
	getResourceHost?: string;
	gameHost?: string;
	phoneHost?: string;
	accountId: string;
	private localStream;
	status: string;
	_debug?: boolean;
	_keyCodeList: number[];
	did: string;
	private rotationMode?;
	private _destroyed;
	_useLocalKeyboard?: boolean;
	_mediaProvider?: string;
	containerDomId: string;
	_cacheToken: STSToken;
	touchHandler: TouchHandler;
	private _commonHandler;
	private _veMessageHandler?;
	protected _localKeyboardHandler: LocalKeyboardExtendHandler;
	private _locationServiceHandler;
	private _remoteAppBackgroundHandler;
	private _clipboardHandler;
	private _clipboardAutoSyncHandler;
	private _fullscreenHandler;
	private _detectDelayHandler;
	private _controlRightHandler;
	private _screenRecordHandler;
	protected _keyboardDisableHandler: KeyboardDisableHandler;
	_networkHandler: NetworkHandler;
	streamingEngine: StreamingEngine;
	private _localAudioHandler;
	private _localCameraHandler;
	private _screenLockHandler;
	private _rotationAutoHandler;
	private _batchEventSyncHandler;
	private _batchStreamHandler;
	logger: Logger;
	sessionId: string;
	protected _startResolve: (value: unknown) => void;
	protected _startReject: (value: unknown) => void;
	protected _startRejectFn: (error: any) => void;
	_needFirstClickPlayAudio: boolean;
	_isRotationGameService: boolean;
	sessionIdState: "start" | "stop";
	podUserId: string;
	_rtc_business_id: string;
	remoteMessager: unknown;
	private isBatchStream;
	get config(): ICGConfig;
	private _removeResizeMonitor;
	private lastTouchTime;
	private _isClusterControl;
	private _isAutoRefreshToken;
	_masterId?: string;
	private _isEventSyncInOtherProcess?;
	_localStreamHandler: LocalStreamHandler;
	_mediaDeviceHandler: MediaDeviceHandler;
	startPromise: Promise<{
		width: number;
		height: number;
	}>;
	retryPodStartCount: number;
	private _startParams;
	static StreamingEngineVersion(): {
		bytertc: string;
		"llama-webrtc": string;
	};
	constructor(options: CloudCoreConfig);
	private initCoreHandlers;
	get canOperate(): boolean;
	static isSupported: typeof isSupportedStatic;
	_isSupported: typeof isSupportedStatic;
	_setOptions(options: CloudCoreConfig): void;
	_getDebugInfo(): {
		userId: string;
		channelDomain: string;
		SDKVersion: string;
		[name: string]: any;
	};
	getVersion(): string;
	_setKeepAliveTime(aliveTime: number): Promise<any>;
	_getKeepAliveTime(): Promise<any>;
	_setGameAudioVolumeUp(): void;
	_setGameAudioVolumeDown(): void;
	_setLocalAudioPlaybackVolume(volume: number): number;
	_getLocalAudioPlaybackVolume(): number;
	_setRemoteLocationMock(location: {
		latitude: number;
		longitude: number;
	}): Promise<{
		latitude: number;
		longitude: number;
	}>;
	_enableLocationService(enable: boolean): void;
	_isLocationServiceEnabled(): boolean;
	_setLocationServiceMode(mode: number): void;
	_getLocationServiceMode(): number;
	_setRemoteGameForeground(): Promise<any>;
	_getRemoteBackgroundAppList(): Promise<string[]>;
	_setRemoteAppForeground(packageName?: string): Promise<void>;
	_initDOM({ domId, customLocalKeyboardInputId, useCustomLocalKeyboardInput, }: {
		domId: string;
		customLocalKeyboardInputId: string;
		useCustomLocalKeyboardInput: boolean;
	}): void;
	_destroyDOM(containerDomId: any): void;
	_init({ containerDomId }: {
		containerDomId: string;
	}): void;
	_initEnableConfig({ containerDomId }: {
		containerDomId: string;
	}): void;
	_markCustomError(msg: string): {
		errorCode: number;
		errorMessage: string;
	};
	_start(params?: CoreStartConfig, retry?: boolean): Promise<any>;
	_openApiStartFail({ err, startTime, reject }: {
		err: any;
		startTime: any;
		reject: any;
	}): void;
	_startStreamingEngine({ engineType, roomId, token, podUserId, rtcAppId, width, height, mute, videoRenderMode, rotation, startTime, isScreenLock, extra, expectedIDC, preJoinRoomData, retry, }: IStartStreamingEngineOptions): Promise<{
		width: number;
		height: number;
	}>;
	private _startLlama;
	private _commonStartAction;
	_restart(): Promise<number>;
	_playByInteraction(reload?: boolean): Promise<void>;
	_touchRotation(rotation?: string | number, gameType?: string): void;
	_stop(isUserStop?: boolean, renewSid?: boolean, isKickedByServer?: boolean): Promise<void>;
	_pauseOrResume(isPause?: boolean): void;
	_renewToken(token: STSToken): void;
	_renewSessionId(): void;
	_updateVideoScale(): void;
	_rotateCoordinate(degree: number): void;
	_rotateCoordinateWithNoCallback(degree: number): void;
	_rotateScreen(degree: number, isPodRotate?: boolean): void;
	_sendRotateEventToGame(rotation: number, duration?: number): Promise<void>;
	_rotate(degree: number): void;
	_getStats(): Promise<{}>;
	_getConnectionState(): string;
	_getDeviceId(): string;
	getResourceStatus(): Promise<string>;
	getVePhonePodStatus(): Promise<{
		podStatus: PodStatus;
	}>;
	updateMediaToken(): Promise<any>;
	_updateRTSToken(skey: string): Promise<any>;
	_changeLocalKeyboardStatus(status: number): void;
	_monitorPod({ monitorPodId, startTime, monitorUserId, monitorToken, monitorAccountId }: {
		monitorPodId: any;
		startTime?: Date;
		monitorUserId: any;
		monitorToken: any;
		monitorAccountId: any;
	}): Promise<unknown>;
	_closeApp(id: string): void;
	_launchApp(id: string): void;
	_sendVEMessage({ message, needAck, timeout, destUserId, key, }: {
		message: ArrayBuffer | string;
		needAck?: boolean;
		timeout?: number;
		destUserId?: string;
		key?: string;
	}): Promise<unknown>;
	_sendClipBoardMessage(text: string): Promise<any>;
	_sendCustomMessage(customMessage: Record<string, any> | ArrayBufferLike): Promise<any>;
	_sendMessage(message: string | any, isBinary?: boolean): Promise<unknown>;
	_sendCustomMessageWithReturn(data: IMessageReturnOptions): Promise<any>;
	_sendTouchMessage(touchMessage: {
		action: number;
		pointerId: number;
		x: number;
		y: number;
	}): void;
	_sendControlMessage(pkgName: string, action: number): void;
	_sendKeycodeMessage({ keycode, action, }: {
		keycode: number;
		action: number;
	}): Promise<unknown>;
	_checkKeycode(keyCode: number): boolean;
	_sendMouseMessage({ button, action, wheel, hwheel, x, y, movementX, movementY, }: {
		button?: number;
		action: number;
		wheel?: number;
		hwheel?: number;
		x?: number;
		y?: number;
		movementX?: number;
		movementY?: number;
	}): Promise<any>;
	_sendKeyboardMessage({ keycode, action, }: {
		keycode: string;
		action: number;
	}): void;
	_sendGamepadButtonMessage({ keycode, action, index, }: {
		keycode: number;
		action: number;
		index?: number;
	}): void;
	_enableLocalAudio(): Promise<void>;
	_disableLocalAudio(): Promise<void>;
	messageReceivedHandler(event: {
		message: string;
	}, userId?: string): void;
	binaryMessageReceviedHandler(event: {
		message: ArrayBuffer;
	}, userId?: string): void;
	seiMessageReceviedHandler(event: any, userId: string): any;
	_setNavigationBarStatus(status: number): Promise<any>;
	_getNavigationBarStatus(): Promise<unknown>;
	_setAudioSourceType(streamType: number, audioSourceType: number): Promise<void>;
	_startExternalAudioTrack(streamIndex: number, mediaStreamTrack: MediaStreamTrack): Promise<void>;
	_stopExternalAudioTrack(): Promise<void>;
	_startSendAudioStream(): Promise<{
		success: boolean;
	}>;
	_stopSendAudioStream(): Promise<0 | -1>;
	_getAudioPlaybackDeviceList(): Promise<MediaDeviceInfo[]>;
	_setAudioPlaybackRoute(deviceId: string): void;
	_getAudioCaptureDeviceList(): Promise<MediaDeviceInfo[]>;
	_setAudioCaptureDevice(deviceId: string): Promise<void>;
	_getAudioPlaybackRoute(): string;
	_getAudioCaptureDevice(): string;
	_setVideoSourceType(streamType: number, videoSourceType: number): Promise<void>;
	_startExternalVideoTrack(streamIndex: number, mediaStreamTrack: MediaStreamTrack): Promise<void>;
	_stopExternalVideoTrack(): Promise<void>;
	_startVideoStream(deviceId?: string): Promise<{
		success: boolean;
	}>;
	_stopVideoStream(): Promise<number>;
	_setVideoCaptureDevice(deviceId: string): Promise<void>;
	_getVideoPlaybackDeviceList(): Promise<MediaDeviceInfo[]>;
	_getVideoCaptureDevice(): string;
	_setLocalVideoView(options: {
		streamIndex: number;
		videoPlayerOption: Partial<VideoPlayerOption>;
	}): boolean;
	_setLocalVideoMirrorMode(mirrorType: number): void;
	_getLocalVideoMirrorMode(): number;
	_setVideoCaptureConfig(config: {
		width?: number;
		height?: number;
		facingMode?: string;
	}): Promise<void>;
	_setVideoEncoderConfig(config: {
		width: number;
		height: number;
		frameRate: number;
		maxKbps: number;
	}): Promise<void>;
	_setReconnectTime(time: number): void;
	_clickVirtualBtn(keycode: number): void;
	_setToHomePage(): void;
	_setBackToPreviousPage(): void;
	_setToRecentAppPage(): void;
	_startRecording(duration: number, isSavedOnPod?: boolean): Promise<void>;
	_stopRecording(): Promise<void>;
	_sendSensorDataToGame(type: any, data?: {
		x: number;
		y: number;
		z: number;
	}): Promise<void>;
	_sendShakeEventToGame(duration?: number): Promise<void>;
	_getFocusedWindowApp(): void;
	_updateVideoRenderMode(videoRenderMode: number): void;
	_destroyHandler(): void;
	_destroy(): Promise<boolean>;
	_enableControl(userId: string, enable: boolean): Promise<ControlEventResult>;
	_hasControl(userId: string): Promise<ControlEventResult>;
	_getAllControls(): Promise<Omit<ControlEventResult, "data"> & {
		data?: ControlState[];
	}>;
	_startVideoPlay(cameraFilePath: string, mode: number): Promise<any>;
	_stopVideoPlay(): Promise<any>;
	_getVideoStatus(): Promise<any>;
	_setKeyboardStyle(keyboard: string): Promise<unknown>;
	_getKeyboardStyle(): Promise<any>;
	_setClusterControl(isCluster: boolean): void;
	_setAudioInjectionState(enable: boolean): Promise<any>;
	_getAudioInjectionState(): Promise<{
		msg: any;
		state: any;
		enable: any;
		code: any;
	}>;
	_setVideoInjectionState(enable: boolean): Promise<any>;
	_getVideoInjectionState(): Promise<{
		msg: any;
		state: any;
		enable: any;
		code: any;
	}>;
	get virtualKeyboard(): any;
	get batchEventSyncHandler(): BatchEventSyncHandler;
	get batchStreamHandler(): BatchStreamHandler;
	_updateExpireTime(token: STSToken, expireTime: number): Promise<void>;
	_getMediaToken(token: STSToken, mediaList: any): Promise<any>;
	_updateVideoRenderSize(): void;
	_batchPodStart(params: any, engine?: "llama" | "bytertc"): Promise<any>;
}
declare class Logger {
	state: any;
	send: any;
	setCommonParams: any;
	constructor();
	getTime(): string;
	print(level: any, stage: any, prefix: any, messageList: any): void;
	getLocalShowGroup(): {
		logShowFlag: boolean;
		levelList: string[];
		stageList: string[];
	};
	localLog(level: any, stage: any, method: any, messageList: any): boolean;
	localWarnLog(stage: any, method: any, ...messageList: any[]): void;
	localErrorLog(stage: any, method: any, ...messageList: any[]): void;
	localInfoLog(stage: any, method: any, ...messageList: any[]): void;
	localTraceLog(stage: any, method: any, ...messageList: any[]): void;
}
export default class vePhoneSDK extends Player {
	static MODE: typeof MODE;
	static ACTION: typeof ACTION;
	static KEYCODE: typeof KEYCODE;
	static MOUSE_BUTTON: typeof MOUSE_BUTTON;
	static LOCATION_SERVICE_MODE: typeof LOCATION_SERVICE_MODE;
	static STREAM_TYPE: {
		STREAM_INDEX_MAIN: number;
		STREAM_INDEX_SCREEN: number;
	};
	static VIDEO_SOURCE_TYPE: {
		VIDEO_SOURCE_TYPE_EXTERNAL: number;
		VIDEO_SOURCE_TYPE_INTERNAL: number;
	};
	static AUDIO_SOURCE_TYPE: {
		AUDIO_SOURCE_TYPE_EXTERNAL: number;
		AUDIO_SOURCE_TYPE_INTERNAL: number;
	};
	static VIDEO_RENDER_MODE: typeof VIDEO_RENDER_MODE;
	static LOGGER: Logger;
	static setSdkType(): void;
	constructor(options: CloudCoreConfig);
	checkSystemRequirements(): boolean;
	getVersion(): string;
	getStats(): Promise<{}>;
	getConnectionState(): string;
	getDeviceId(): string;
	setOptions(options: CloudCoreConfig): void;
	getDebugInfo(): {
		[name: string]: any;
		userId: string;
		channelDomain: string;
		SDKVersion: string;
	};
	setIdleTime(time: number): Promise<void>;
	getIdleTime(): Promise<void>;
	volumeUp(): void;
	volumeDown(): void;
	setGameAudioVolumeUp(): void;
	setGameAudioVolumeDown(): void;
	setLocalAudioPlaybackVolume(volume: number): void;
	getLocalAudioPlaybackVolume(): number;
	setAutoRecycleTime(duration: number): Promise<void>;
	getAutoRecycleTime(): Promise<{
		time: number;
	}>;
	setRemoteLocationMock(location: {
		latitude: number;
		longitude: number;
	}): Promise<{
		latitude: number;
		longitude: number;
	}>;
	enableLocationService(enable: boolean): void;
	isLocationServiceEnabled(): boolean;
	setLocationServiceMode(mode: number): void;
	getLocationServiceMode(): number;
	getRemoteBackgroundAppList(): Promise<string[]>;
	setRemoteAppForeground(packageName?: string): Promise<void>;
	start(options: CoreStartConfig): Promise<any>;
	restart(): Promise<number>;
	startRTC(startRTCOptions: StartRTCOptions): any;
	playByInteraction(reload?: boolean): Promise<void>;
	monitorPod(options: {
		monitorPodId: string;
		startTime?: Date;
		monitorUserId: string;
		monitorToken: string;
		monitorAccountId: string;
	}): Promise<unknown>;
	stop(): Promise<void>;
	pause(): void;
	resume(): void;
	rotateCoordinate(degree: number): void;
	rotateScreen(degree: number, isPodRotate?: boolean): void;
	rotate(degree: number): void;
	setAudioMute(mute: boolean): void;
	isAudioMuted(): boolean;
	isVideoMuted(): boolean;
	muteAudio(mute: boolean): Promise<void>;
	muteVideo(mute: boolean): Promise<void>;
	closeApp(id: string): void;
	launchApp(id: string): void;
	sendMessage({ message, needAck, timeout, destUserId, }: {
		message: ArrayBuffer | string;
		needAck?: boolean;
		timeout?: number;
		destUserId?: string;
	}): Promise<number>;
	sendClipBoardMessage(text: string): Promise<any>;
	sendCustomMessage(customMessage: Record<string, any>): Promise<any>;
	enableMicInnerRecord(enable: boolean): Promise<unknown>;
	sendTouchMessage(touchMessage: {
		action: number;
		pointerId: number;
		x: number;
		y: number;
	}): void;
	sendKeycodeMessage(keycodeMessage: {
		keycode: number;
		action: number;
	}): Promise<unknown>;
	sendMouseMessage(mouseMessage: {
		button?: number;
		action: number;
		wheel?: number;
		x: number;
		y: number;
	}): void;
	enableLocalAudio(): Promise<void>;
	disableLocalAudio(): Promise<void>;
	setVideoStreamProfileId(id: number): Promise<{
		result: number;
		reason: string;
		before: string;
		after: string;
	}>;
	switchVideoStreamProfile(id: number): Promise<{
		result: number;
		reason: string;
		before: string;
		after: string;
	}>;
	getVideoStreamProfileId(): Promise<{
		result: number;
		reason: string;
		before: string;
		after: string;
	}>;
	switchBackground(on: boolean): Promise<any>;
	setFullScreenState(state: boolean, options: {
		fitMode: string;
	}): any;
	setAudioSourceType(streamType: number, audioSourceType: number): Promise<void>;
	startExternalAudioTrack(streamIndex: number, mediaStreamTrack: MediaStreamTrack): Promise<void>;
	stopExternalAudioTrack(): Promise<void>;
	startSendAudioStream(): Promise<{
		success: boolean;
	}>;
	stopSendAudioStream(): Promise<0 | -1>;
	getAudioPlaybackDeviceList(): Promise<MediaDeviceInfo[]>;
	setAudioPlaybackDevice(deviceId: string): void;
	getAudioCaptureDeviceList(): Promise<MediaDeviceInfo[]>;
	setAudioCaptureDevice(deviceId: string): Promise<void>;
	getAudioPlaybackDevice(): string;
	getAudioCaptureDevice(): string;
	setVideoSourceType(streamType: number, videoSourceType: number): Promise<void>;
	startExternalVideoTrack(streamIndex: number, mediaStreamTrack: MediaStreamTrack): Promise<void>;
	stopExternalVideoTrack(): Promise<void>;
	startVideoStream(deviceId?: string): Promise<{
		success: boolean;
	}>;
	stopVideoStream(): Promise<number>;
	switchCamera(deviceId: string): Promise<void>;
	getVideoPlaybackDeviceList(): Promise<MediaDeviceInfo[]>;
	getVideoCaptureDevice(): string;
	setLocalVideoView(options: {
		streamIndex: number;
		videoPlayerOption: Partial<VideoPlayerOption>;
	}): boolean;
	setLocalVideoMirrorMode(mirrorType: number): void;
	getLocalVideoMirrorMode(): number;
	setVideoCaptureConfig(config: {
		width?: string;
		height?: string;
		facingMode?: string;
	}): Promise<void>;
	setVideoEncoderConfig(config: {
		width: number;
		height: number;
		frameRate: number;
		maxKbps: number;
	}): Promise<void>;
	setReconnectTime(time: number): void;
	setToHomePage(): void;
	setBackToPreviousPage(): void;
	setToRecentAppPage(): void;
	screenShot(isSavedOnPod: boolean): Promise<{
		result: any;
		savePath: any;
		message: string;
		downloadUrl: string;
	}>;
	screenShotLocal(autoDownload?: boolean): void;
	getFocusedWindowApp(): void;
	destroy(): Promise<boolean>;
	startRecording(duration: number, isSavedOnPod?: boolean): Promise<void>;
	stopRecording(): Promise<void>;
	startPushFile(file: File, { folder, name, }: {
		folder: string;
		name: string;
	}): void;
	stopPushFile(): void;
	startPullFile({ folder, name, returnUrl, }: {
		folder: string;
		name: string;
		returnUrl?: boolean;
		expires?: number;
	}): void;
	stopPullFile(): void;
	setReturnUrl(bool?: boolean): void;
	sendShakeEventToGame(duration: number): Promise<void>;
	setNavBarStatus(status: number): Promise<void>;
	getNavBarStatus(): Promise<{
		status: number;
		reason?: number;
	}>;
	updateVideoRenderMode(videoRenderMode: number): void;
	changeLocalKeyboardStatus(status: number): void;
	startVideoPlay(cameraFilePath: string, mode: number): Promise<any>;
	stopVideoPlay(): Promise<any>;
	getVideoStatus(): Promise<any>;
	enableControl(userId: string, enable: boolean): Promise<ControlEventResult>;
	hasControl(userId: string): Promise<ControlEventResult>;
	getAllControls(): Promise<Omit<ControlEventResult, "data"> & {
		data?: ControlState[];
	}>;
	setKeyboardStyle(keyboard: string): Promise<unknown>;
	getKeyboardStyle(): Promise<any>;
	enableFullScreen(enable: boolean): any;
	setClusterControl(isCluster: boolean): void;
	setAudioInjectionState(enable: boolean): Promise<any>;
	getAudioInjectionState(): Promise<{
		msg: any;
		state: any;
		enable: any;
		code: any;
	}>;
	setVideoInjectionState(enable: boolean): Promise<any>;
	getVideoInjectionState(): Promise<{
		msg: any;
		state: any;
		enable: any;
		code: any;
	}>;
	renewSessionId(): void;
	updateExpireTime(token: STSToken, expireTime: number): Promise<void>;
	updateVideoRenderSize(): void;
	sendInputText(text: string): any;
	coverCurrentEditText(text: string): any;
}

export {};