import { VideoPlayerOption } from '@volcengine/rtc';

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 veGameSDK extends ApiHubGame {
	static MODE: any;
	static ACTION: any;
	static KEYCODE: any;
	static MOUSE_BUTTON: any;
	static GAMEPAD_BUTTON: any;
	static VIDEO_RENDER_MODE: any;
	static LOGGER: Logger;
	static setSdkType(): void;
	static getDeviceId(): any;
	checkSystemRequirements(): boolean;
	getVersion(): any;
	getStats(): any;
	getConnectionState(): any;
	getDeviceId(): any;
	get isAudioPlaying(): any;
	setOptions(options: CloudCoreConfig): void;
	getDebugInfo(): any;
	setIdleTime(time: number): any;
	setGameAudioVolumeUp(): void;
	setGameAudioVolumeDown(): void;
	setLocalAudioPlaybackVolume(volume: number): void;
	getLocalAudioPlaybackVolume(): any;
	setAutoRecycleTime(duration: number): any;
	getAutoRecycleTime(): any;
	setUserProfilePath(pathList: string[]): any;
	getUserProfilePath(): any;
	setRemoteGameForeground(): any;
	start(options: CoreStartConfig): Promise<CoreStartSuccessReturn>;
	restart(): any;
	startRTC(startRTCOptions: StartRTCOptions): any;
	startSocket(startSocketOptions: StartSocketConfig): any;
	playByInteraction(reload?: boolean): any;
	videoPlay(): any;
	stop(): any;
	pause(): any;
	resume(): any;
	renewToken(stsToken: STSToken): void;
	updateVideoScale(): void;
	rotateCoordinate(degree: number): void;
	rotate(degree: number): void;
	setAudioMute(mute: boolean): void;
	closeApp(id: string): void;
	launchApp(id: string): void;
	sendMessage({ message, needAck, timeout, destUserId, key, useProxy, }: {
		message: ArrayBuffer | string;
		needAck?: boolean;
		timeout?: number;
		destUserId?: string;
		key?: string;
		useProxy?: boolean;
	}): any;
	sendClipBoardMessage(text: string): any;
	sendCustomMessage(customMessage: Record<string, any>): any;
	sendTouchMessage(touchMessage: {
		action: number;
		pointerId: number;
		x: number;
		y: number;
	}): any;
	sendKeycodeMessage(keycodeMessage: {
		keycode: number;
		action: number;
	}): any;
	sendMouseMessage(mouseMessage: {
		button?: number;
		action: number;
		wheel?: number;
		x?: number;
		y?: number;
		movementX?: number;
		movementY?: number;
	}): void;
	sendKeyboardMessage(keyboardMessage: {
		keycode: string;
		action: number;
	}): any;
	sendGamepadButtonMessage(gamepadMessage: {
		keycode: number;
		action: number;
		index?: number;
	}): any;
	sendJoystickMessage(joystickMessage: {
		leftX: number;
		leftY: number;
		rightX: number;
		rightY: number;
		leftT: number;
		rightT: number;
		index?: number;
	}): void;
	enableLocalAudio(): any;
	disableLocalAudio(): any;
	switchVideoStreamProfile(id: number): any;
	switchBackground(on: boolean): any;
	setFullScreenState(state: boolean, options: {
		fitMode: string;
	}): any;
	startSendAudioStream(): any;
	stopSendAudioStream(): any;
	getAudioPlaybackDeviceList(): any;
	setAudioPlaybackDevice(deviceId: string): any;
	getAudioCaptureDeviceList(): any;
	setAudioCaptureDevice(deviceId: string): any;
	getAudioPlaybackDevice(): any;
	getAudioCaptureDevice(): any;
	startVideoStream(deviceId?: string): any;
	stopVideoStream(): any;
	switchCamera(deviceId: string): any;
	getVideoPlaybackDeviceList(): any;
	getVideoCaptureDevice(): any;
	setLocalVideoView(options: {
		streamIndex: number;
		videoPlayerOption: Partial<VideoPlayerOption>;
	}): any;
	setVideoRotationMode(options: unknown): any;
	setLocalVideoMirrorMode(mirrorType: number): any;
	getLocalVideoMirrorMode(): any;
	setVideoCaptureConfig(config: {
		width?: string;
		height?: string;
		facingMode?: string;
	}): any;
	setVideoEncoderConfig(config: {
		width: number;
		height: number;
		frameRate: number;
		maxKbps: number;
	}): any;
	setReconnectTime(time: number): any;
	sendGravitySensorDataToGame(data: {
		x: number;
		y: number;
		z: number;
	}): any;
	sendShakeEventToGame(repeat: number): any;
	sendAccelerationDataToGame(data: {
		x: number;
		y: number;
		z: number;
	}): any;
	setSystemCursorShowStatControlKey(keyCode: string): any;
	setSystemCursorShowStat(show: boolean): any;
	setSystemCursorSensitivity(sensitivity: number): any;
	destroy(): any;
	sendData(file: File | ArrayBuffer, needAck?: boolean): number;
	startSendFileP2P(file: File | ArrayBuffer, options?: {
		jsonOption?: string;
		name?: string;
		sliceSize?: number;
	}): Promise<boolean>;
	stopSendFileP2P(file: File | ArrayBuffer, options?: {
		jsonOption?: string;
		name?: string;
		sliceSize?: number;
	}): Promise<boolean>;
	startSendFile(file: any, { options }: {
		options: any;
	}): void;
	stopSendFile(): void;
	pauseSendFile(): void;
	stopReceiveFile(): void;
	pauseReceiveFile(): void;
	changeRole(data: {
		userId: string;
		role: 0 | 1;
	}): any;
	setIMECompositionVisible(visible: boolean, style?: string): void;
	setKeyboardEnable(bool: boolean): Promise<void>;
	getKeyboardEnable(): boolean;
	syncLocalKeyboardCloseStatus(): Promise<void>;
	updateVideoRenderMode(videoRenderMode: number): any;
	get GamePad(): any;
	get Mouse(): any;
	get Keyboard(): any;
	get Enum(): any;
	setSessionMode(mode: 0 | 1): any;
	setCustomLocalKeyboardInputId(inputDomId: string): void;
	clearCustomLocalKeyboardInput(): void;
	setDetectInterval(interval: number): boolean;
	setIdleReminderDuration(time: number): Promise<{
		success: boolean;
		message: string;
		result?: number;
	}>;
	getIdleReminderDuration(): Promise<number>;
	resetIdleReminderDuration(): Promise<boolean>;
	setDefaultCursorImage(url: string): any;
	setRemoteCursorMode(mode: 0 | 1): any;
	setMouseMoveInterval(interval: number): any;
	setVideoStreamParam(params: Partial<IVideoStreamParam>): any;
	setResolution(resolution: number): any;
	setBitrateRange(minBitrate: number, maxBitrate?: number): any;
	setFps(frameRate: number): any;
	setExitPointTimeout(time: number): any;
	openSuperResolution(enabled: boolean): any;
	generateSolutionMessage(params: {
		deviceWidth: number;
		deviceHeight: number;
	}): any;
}

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

export 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 GAMEPAD_BUTTON: {
	KEYCODE_BUTTON_A: number;
	KEYCODE_BUTTON_B: number;
	KEYCODE_BUTTON_X: number;
	KEYCODE_BUTTON_Y: number;
	KEYCODE_BUTTON_START: number;
	KEYCODE_BUTTON_SELECT: number;
	KEYCODE_BUTTON_L1: number;
	KEYCODE_BUTTON_R1: number;
	KEYCODE_BUTTON_L2: number;
	KEYCODE_BUTTON_R2: number;
	KEYCODE_BUTTON_THUMBL: number;
	KEYCODE_BUTTON_THUMBR: number;
	KEYCODE_DPAD_UP: number;
	KEYCODE_DPAD_DOWN: number;
	KEYCODE_DPAD_LEFT: number;
	KEYCODE_DPAD_RIGHT: number;
	KEYCODE_DPAD_UP_LEFT: number;
	KEYCODE_DPAD_DOWN_LEFT: number;
	KEYCODE_DPAD_UP_RIGHT: number;
	KEYCODE_DPAD_DOWN_RIGHT: number;
};
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: string;
		fn: any;
	}[];
	setElement(el: HTMLElement): void;
	private getTarget;
	add(name: Record<string, any>, fn?: any): 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;
}
export interface IPCTouch {
	id: number;
	type: number;
	w: number;
	h: number;
	x: number;
	y: number;
	radius: number;
	pressure: number;
}
declare class PCTouchKeeper {
	history: Record<string, {
		timer: any;
		touch: IPCTouch | null;
		hasTouch: boolean;
	}>;
	send: (touches: IPCTouch[]) => void;
	constructor(send: (touches: IPCTouch[]) => void);
	onPCTouch(touches: IPCTouch[]): void;
	private startHeartBeat;
}
declare class TouchSender {
	private _touchCacheMap;
	touchUnifier: TouchIdUnifier;
	parent: any;
	pcTouchKeeper: PCTouchKeeper;
	private _touchDataCache;
	constructor(parent: any);
	private _modifyTouchCache;
	private generateTouchList;
	clearAllTouch(): void;
	get isPCTouch(): boolean;
	private sendTouchList;
	send(touchMessage: any): void;
	private countSendAction;
	private countPCTouchAction;
}
export interface IDecodedMessage {
	type: number;
	subtype: number;
	msg: any;
}
export interface IConnectedEventData {
	mapping: string;
	index: number;
	id: string;
	buttonCount: number;
	axesCount: number;
}
export interface IGamePadEvent {
	onConnected?: (options: IConnectedEventData) => void;
	onDisConnected?: (options: Pick<IConnectedEventData, "mapping" | "id" | "index">) => void;
	onLoopEvent?: (gamepads: Gamepad[]) => void;
}
declare class GamePadProxy {
	inLoop: boolean;
	connected: boolean;
	supported: boolean;
	private connected_list;
	private disconnected_list;
	private event_list;
	constructor();
	getGamepads(): Gamepad[];
	on(name: "connected", fn: IGamePadEvent["onConnected"]): void;
	on(name: "disconnected", fn: IGamePadEvent["onDisConnected"]): void;
	on(name: "event", fn: IGamePadEvent["onLoopEvent"]): void;
	remove(name: "connected" | "disconnected" | "event", fn: IGamePadEvent[keyof IGamePadEvent]): void;
	private gamepadLoop;
	private handleGamepadDisconnected;
	private handleGamePadConnected;
	private triggerGamepad;
	private initGamePadEvent;
	initGamePadsState(): void;
	vibrate(index: number): void;
	private _vibrate;
	destroy(): void;
}
declare class GamePadHandler extends BaseHandler {
	gamePadProxy: GamePadProxy;
	rightStickRate: number;
	pbType: number;
	pbSubTypes: number[];
	init(): void;
	private sendDeviceMsg;
	onMessage({ type, subtype, msg }: {
		type: any;
		subtype: any;
		msg: any;
	}): void;
	private _lastValue;
	handleGamePads(gamepads: Gamepad[]): void;
	destroy(): 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 enum BtnAction {
	Down = 0,
	Up = 1
}
declare enum GamePadKey {
	A,
	B,
	X,
	Y,
	LeftShoulder,
	RightShoulder,
	Back,
	Menu,
	LeftThumb,
	RightThumb,
	Up,
	Down,
	Left,
	Right
}
declare enum WhichDir {
	Left = 0,
	Right = 1
}
declare class GamePadApi {
	private _parent;
	private _state;
	constructor(parent: BaseHandler);
	private _getState;
	sendGamePadRockerEvent({ index, x, y, which, }: {
		index?: number;
		which?: WhichDir;
		x: number;
		y: number;
	}): void;
	sendTriggerButton({ index, which, value, }: {
		index?: number;
		which: WhichDir;
		value: number;
	}): void;
	sendKeyEvent({ key, action, index, }: {
		key: GamePadKey;
		action: BtnAction;
		index?: number;
	}): void;
	onVibrate(func: (msg: {
		index: number;
		l: number;
		r: number;
	}) => void): void;
	private _sendGamePad;
}
declare enum MouseBtnValue {
	Left = 0,
	WheelBtn = 1,
	Right = 2,
	X1 = 3,
	X2 = 4
}
declare class MouseApi {
	private _parent;
	private _touchToMouseListener;
	constructor(parent: BaseHandler);
	private _touchToMouse;
	private _touchToMouseCall;
	setTouchToMouse(bool?: boolean): void;
	setMouseStateListener(listener: (status: "show" | "hidden") => void): void;
	sendInputMouseMove(x: number, y: number, movementX?: number, movementY?: number): void;
	sendInputMouseKey(button: MouseBtnValue, action: BtnAction, x: number, y: number): Promise<any>;
	sendInputMouseWheel(wheel: number, hwheel?: number): Promise<any>;
	sendInputCursorPos(x: number, y: number): Promise<any>;
}
declare class HardwareApiHandler extends BaseHandler {
	static handlerName: string;
	Enum: {
		MouseBtnValue: typeof MouseBtnValue;
		GamePadKey: typeof GamePadKey;
		WhichDir: typeof WhichDir;
		BtnAction: typeof BtnAction;
	};
	GamePad: GamePadApi;
	Mouse: MouseApi;
	Keyboard: {
		sendKeyboard: (keycode: string, action: ACTION) => Promise<unknown>;
	};
	init(): void;
}
declare enum SessionMode {
	Normal = 0,
	HangUp = 1
}
declare class HangUpHandler extends BaseHandler {
	mode: SessionMode;
	pbType: number;
	pbSubTypes: number[];
	get isHangUpMode(): boolean;
	get canSetSessionMode(): boolean;
	initMode(mode: SessionMode): void;
	setSessionMode(mode: SessionMode): Promise<{
		success: boolean;
		msg: string;
	} | {
		success: boolean;
		err: any;
		msg: string;
	}>;
	hangUpPause(pause?: boolean): Promise<{
		success: boolean;
		data: any;
		fromCatch?: boolean;
		err?: any;
	}>;
}
declare class MessageShieldHandler extends BaseHandler {
	pbType: number;
	pbSubTypes: number[];
	onMessage({ msg, type, subtype }: {
		type: number;
		subtype: number;
		msg: any;
	}): void;
}
declare class QueueHandler extends BaseHandler {
	queuePriority: number;
	interval: number;
	timer: any;
	body: any;
	canceled: boolean;
	queueSuccess: boolean;
	private queueSkey;
	private addQueueTs;
	private isFirst;
	getStartSize: () => any;
	clearState(): void;
	setQueuePriority(priority: number): void;
	get needUseQueue(): boolean;
	gameStart(body: any, getStartSize: any): Promise<any>;
	private loopQueryQueue;
	private innerGameStart;
	cancelQueue(): Promise<boolean>;
	private fetchQueryQueue;
	private checkQueueList;
	private addUserQueue;
	destroy(): void;
}
declare class MessageHandler extends BaseHandler {
}
declare class CursorPosHandler extends BaseHandler {
	enabled: boolean;
	isActive: boolean;
	timer: any;
	lastMsg: string;
	lastRateX: number;
	lastRateY: number;
	pointLockRate: number;
	mouseMoveRate: number;
	pbType: number;
	pbSubTypes: number[];
	received: boolean;
	onMessage({ msg }: IDecodedMessage): void;
	private startTimer;
	get isEnable(): boolean;
	onMouseMove({ isPointLock, clientWidth, clientHeight, offsetLeft, offsetTop, movementX, movementY, }: {
		isPointLock: any;
		clientWidth: any;
		clientHeight: any;
		offsetLeft: any;
		offsetTop: any;
		movementX: any;
		movementY: any;
	}): {
		clientX: any;
		clientY: any;
	};
	init(): void;
	destroy(): void;
}
export interface CloudCoreConfig {
	userId: string;
	domId: string;
	accountId: string;
	region?: string;
	isPC?: boolean;
	containerDomId?: string;
	isVePhone?: boolean;
	mode?: number;
	disableInteraction?: boolean;
	getResourceHost?: string;
	gameHost?: string;
	clientMode?: unknown;
	phoneHost?: string;
	isDebug?: boolean;
	debug?: boolean;
	enableSyncClipboard?: boolean;
	enableLocationService?: boolean;
	enableLocalKeyboard?: boolean;
	enableLocalMouseScroll?: boolean;
	disableAudioInjection?: boolean;
	mouseWheelDirectionFollowSystem?: boolean;
	disableDefaultTouchEvent?: boolean;
	needConnectFileChannel?: boolean;
	mediaProvider?: string;
	isSocketSupport?: boolean;
	keyCodeList?: number[];
	podSettings?: {
		type?: 0 | 1 | 2;
		max_pcu?: number;
		role?: 0 | 1;
	};
	customLocalKeyboardInputId?: string;
	usePB?: boolean;
	useCustomLocalKeyboardInput?: boolean;
	config?: ICGConfig;
	isClusterControl?: boolean;
	useMcc?: boolean;
}
export interface STSToken {
	SessionToken: string;
	AccessKeyID: string;
	SecretAccessKey: string;
	ExpiredTime?: string;
	CurrentTime?: string;
}
export interface IVideoStreamParam {
	frameRate: number;
	maxBitrate: number;
	minBitrate: number;
	resolution: number;
}
export interface CoreStartConfig {
	gameId?: string;
	customGameId?: string;
	productId?: string;
	mute?: boolean;
	token: STSToken;
	roundId: string;
	videoStreamProfileId?: number;
	videoStreamParams?: IVideoStreamParam;
	planId?: string;
	rotation?: string;
	gameRotation?: 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_websocket" | string;
	autoRecycleTime?: number;
	waitTime?: number;
	userProfilePathList?: string[];
	remoteLocationMock?: {
		latitude: number;
		longitude: number;
	};
	enableFullScreen?: boolean;
	useCloudNative?: boolean;
	systemCursorShowStatManual?: boolean;
	keyboardEnable?: boolean;
	videoRenderMode?: number;
	remoteWindowSize?: {
		width: number;
		height: number;
	};
	sessionMode?: number;
	queuePriority?: number;
	hasVideoBlackPadding?: boolean;
	isPcPortraitGame?: boolean;
	idleReminderDuration?: number;
	isSimpleFetch?: boolean;
	maxUsedTime?: number;
	srOptions?: {
		mode?: "bicubic" | "enhance";
		config?: {
			scale?: number;
		} | {
			sharpness?: number;
			contrast?: number;
			saturation?: number;
		};
	};
}
export interface CoreStartSuccessReturn {
	width: number;
	height: number;
	roundId: string;
	gameId: string;
	reservedId: string;
	extra?: Record<string, string>;
}
export interface StartSocketConfig {
	url: URL | string;
	token: STSToken;
	podUserId: string;
	domWidth?: number;
	domHeight?: number;
	width: number | string;
	height: number | string;
	mute?: boolean;
	rotation?: string | number;
	startTime?: Date;
	roundId: string;
	videoRenderMode?: number;
	extra?: Record<string, string>;
}
export interface StartRTCOptions {
	roomId: string;
	podUserId: string;
	rtcAppId: string;
	width: number | string;
	height: number | string;
	mute?: boolean;
	isScreenLock?: boolean;
	token: STSToken | string | unknown;
	videoRenderMode?: number;
	rotation?: string | number;
	startTime?: Date;
	extra?: Record<string, string>;
	gameType?: string;
	noScale?: boolean;
	noScaleAndLandscape?: boolean;
	isHaiMACloud?: boolean;
	expectedIDC?: string;
}
export declare type EmitterMethod = (type: string, listener: EventListener) => void;
export declare type ISROptions = Partial<Pick<ISuperResolutionOptions, "config" | "mode">> & {
	enabled?: boolean;
};
export interface ICGConfig {
	shouldPlayWhenPause?: boolean;
	enableScreenRotationTouch?: boolean;
	disableNetworkMonitor?: boolean;
	expectedIdc?: string;
	enableVirtualKeyboard?: boolean;
	needRotateVirtualKeyboard?: boolean;
	customSDKVersion?: string;
	mouseAndTouch?: "auto" | "mouse" | "touch" | "both";
	enhanceEscFunction?: boolean;
	lockEscape?: boolean;
	exitPointerLockTime?: number;
	needFormatStreamSize?: boolean;
	serverConfig?: {
		jitter_buffer?: {
			max_value?: number;
			account_id_list?: string;
		};
		downgrade_webts_to_bytertc?: boolean;
		webts_gate_config?: {
			"bwa": {
				"enable_adjust_with_loss": boolean;
				"loss_penalty_base": number;
				"loss_rate_change_threshold": number;
				"min_adjust_interval_ms": number;
			};
			"loss_rate": {
				"enable_ewma": boolean;
				"ewma_alpha": number;
			};
		};
	};
}
export interface ICGStore {
	gameHost?: string;
	accountId?: string;
	enableLocalKeyboard?: boolean;
	userId?: string;
	mode?: number;
	isPC?: boolean;
	queuePriority?: number;
	sessionMode?: number;
	videoStreamProfileId?: number;
	videoStreamParams?: IVideoStreamParam;
	gameId?: string;
	productId?: string;
	token?: STSToken;
	rotation?: string;
	gameRotation?: string;
	isScreenLock?: boolean;
	reservedId?: string;
	deviceId?: string;
	sessionId?: string;
	skey?: string;
	roundId?: string;
	expectedIdc?: string;
	isPcPortraitGame?: boolean;
	useWebts?: boolean;
	paasGameRotation?: string;
	podExited?: boolean;
	srOptions?: ISROptions;
	gameType?: "pc" | "android";
}
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 readonly handlerName = "ConfigHandler";
	_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;
	initServerConfig(config?: string): void;
	isAccountIdHit(accountIds?: string): boolean;
}
declare class StuckMonitorHandler extends BaseHandler {
	static handlerName: string;
	private decodeFPS;
	private receiveFPS;
	private listener;
	init(): void;
	destroy(): void;
}
declare class IdleReminderHandler extends BaseHandler {
	pbType: number;
	pbSubTypes: number[];
	onMessage({ msg }: {
		type: number;
		subtype: number;
		msg: any;
	}): void;
	resetIdleReminderDuration(): Promise<boolean>;
	setIdleReminderDuration(time: number): Promise<{
		success: boolean;
		countdown?: number;
		message: string;
		result?: any;
	}>;
	getIdleReminderDuration(): Promise<number>;
	private sendIdleReminderMessage;
	private _sendError;
}
declare function createEmptyABMap(): {
	engine: string;
	codec: string;
	cascade: string;
	jb: string;
	bwa: string;
};
export declare type IABKey = keyof ReturnType<typeof createEmptyABMap>;
declare class ABTestHandler extends BaseHandler {
	abTestMap: {
		engine: string;
		codec: string;
		cascade: string;
		jb: string;
		bwa: string;
	};
	extraInfo: string;
	private _timer;
	init(): void;
	private fillAbTestMap;
	collectABGroupInfo(key: IABKey, value: string): void;
	disableABGroupInfo(key: IABKey): Promise<void>;
	private isABInfoComplete;
	private _sended;
	sendABInfo(): void;
	destroy(): void;
}
declare class RestHandler extends BaseHandler {
	acceptAllMsg: boolean;
	init(): void;
	onMessage(msg: {
		type: number;
		subtype: number;
		msg: any;
	}): boolean;
	private initWebTsSupportLog;
	private checkBrowserEvent;
}
declare class VideoStreamParamHandler extends BaseHandler {
	static handlerName: string;
	private _enabled;
	init(): void;
	checkParams(params: IVideoStreamParam): string;
	setVideoStreamParam(params: Partial<IVideoStreamParam>): Promise<any>;
}
declare class SRHandler extends BaseHandler {
	enabled: boolean;
	active: boolean;
	superResolution: SuperResolution;
	init(): void;
	initVideo(video: HTMLVideoElement): HTMLVideoElement;
	onSrOptions(srOptions: ISROptions): void;
	openSuperResolution(enabled: boolean, fromInit?: boolean): void;
	reInitCanvas(size?: {
		width: number;
		height: number;
	}): void;
	setSRParam(config: Partial<ISuperResolutionOptions["config"]>): void;
	switchMode(mode: ISRMode): void;
	destroy(): void;
}
export interface PingResult {
	Area: string;
	Ping: number;
}
declare class NetSpeedHandler extends BaseUtilHandler {
	private createTimeoutSignal;
	private calculatePingSum;
	private hasInvalidPing;
	private selectBestPingList;
	getNodeList(token: STSToken, timeout: number): Promise<PingResult[]>;
	private testNode;
	private testSingle;
}
declare class HandleManagerBase {
	GamePadHandler: GamePadHandler;
	PageLifeHandler: PageLifeHandler;
	HardwareApiHandler: HardwareApiHandler;
	HangUpHandler: HangUpHandler;
	MessageShieldHandler: MessageShieldHandler;
	QueueHandler: QueueHandler;
	MessageHandler: MessageHandler;
	CursorPosHandler: CursorPosHandler;
	ConfigHandler: ConfigHandler;
	StuckMonitorHandler: StuckMonitorHandler;
	IdleReminderHandler: IdleReminderHandler;
	ABTestHandler: ABTestHandler;
	RestHandler: RestHandler;
	VideoStreamParamHandler: VideoStreamParamHandler;
	SRHandler: SRHandler;
	NetSpeedHandler: NetSpeedHandler;
}
declare function useHandler(handler: any): boolean;
declare class HandleManager extends HandleManagerBase {
	[prop: string]: any;
	private _keys;
	constructor(player: Player);
	initHandlers(): void;
	handleMessage(decodedMessage: {
		type: any;
		subtype: any;
		msg: any;
	}): boolean;
	destroy(): void;
}
export interface IMessageReturnOptions {
	message: any;
	jsonCmd?: any;
	pbType?: number;
	pbSubType?: number;
	transformPBMes?: (msg: any) => any;
	timeout?: number;
	onTimeout?: () => void;
	onExec?: () => void;
	throwGeneral?: boolean;
}
declare class BaseUtilHandler implements IConfigHelper {
	static handlerName?: string;
	static needHandleMsg: boolean;
	player: Player;
	protected _localLog: boolean;
	constructor(player: Player);
	get isPhone(): boolean;
	get isPCGame(): boolean;
	init(): void;
	destroy(): void;
	fetchBase(data: any): Promise<any>;
	fetchInnerApi(data: any): Promise<any>;
	on(name: string, fn: (v: any) => void): void;
	once(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: Record<string, any> | {
			accountId: string;
			volcProduct: "veGame" | "vePhone";
			initSessionId: string;
			sessionId: string;
			uuid: string;
		};
		initConfig: {
			userId: string;
			channelDomain: string;
			SDKVersion: string;
		};
	};
	print(...args: any[]): void;
	printTraceLog(...args: any[]): void;
	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;
	set renderEle(video: HTMLVideoElement);
	handleMessage(decodedMessage: IDecodedMessage): boolean;
}
export declare class BaseHandler extends BaseUtilHandler {
	static needHandleMsg: boolean;
	manager: HandleManager;
	pbType: number;
	pbSubTypes: number[];
	acceptAllMsg: boolean;
	constructor(player: Player, manager: HandleManager);
	handleMessage(decodedMessage: IDecodedMessage): boolean;
	onMessage(decodedMessage: {
		type: number;
		subtype: number;
		msg: 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<void> | Promise<{
		error: any;
		message: any;
		isBinary: boolean;
	}>;
	sendMessageWithReturn({ message, jsonCmd, pbType, pbSubType, transformPBMes, timeout, onTimeout, onExec, throwGeneral, }: IMessageReturnOptions): Promise<{
		success: boolean;
		data: any;
		fromCatch?: boolean;
		err?: any;
	}>;
	protected _onHandleMessage({ message, jsonCmd, pbType, pbSubType, transformPBMes, timeout, onTimeout, onExec, }: {
		message: any;
		jsonCmd: any;
		pbType: any;
		pbSubType: any;
		transformPBMes?: (msg: any) => any;
		timeout?: number;
		onTimeout?: any;
		onExec?: any;
	}): Promise<unknown>;
	encodePBMessage(data: {
		msgName: string;
		payload: any;
		type: number;
		subType: number;
	}): ArrayBufferLike;
}
declare enum CursorMode {
	LocalImg = 0,
	PodImg = 1
}
declare class SystemCursorImage extends BaseHandler {
	private localImgUrl;
	private mode;
	private prevMsg;
	onCursorImgMsg(msg: IDecodedMessage): boolean;
	private isShowCursorMode;
	private isTransparentImage;
	private renderCursor;
	private setStyle;
	setDefaultCursorImage(url: string): number;
	setRemoteCursorMode(mode: CursorMode): number;
}
declare function enhanceEscFunction(player: Player, causeLockKeys?: string[]): {
	hasSendEsc: boolean;
	enableEnhanceEsc: boolean;
	preventEscKeyDown(): boolean;
	resetSendEsc(): void;
	Const: {
		WaitKeyActionTime: number;
		WaitLockTime: number;
		WaitNextEsc: number;
		WaitUpdateCacheMouseShow: number;
		WaitCauseLockKey: number;
	};
	onShowMessage(show: boolean): void;
};
declare class SystemCursorShowStatHandler {
	cursorImage: SystemCursorImage;
	private _player;
	private _systemCursorShowStatManual;
	private _systemCursorShowStatControlKey;
	private _cursorSensitivity;
	enhanceEscInfo?: ReturnType<typeof enhanceEscFunction> | undefined;
	private removePointLockEvent;
	constructor(player: Player, { systemCursorShowStatManual }?: {
		systemCursorShowStatManual?: boolean;
	});
	isRemoteMouseShow: boolean;
	isLocalMouseShow: boolean;
	get cursorSensitivity(): number;
	private _isCursorImageShow;
	private _isVisibilityShow;
	handleMessage(pbMessage: IDecodedMessage): void;
	setSystemCursorShowAuto(triggerEventName: "mousedown" | "mousemove" | "wheel" | "keydown"): void;
	private _setLock;
	private checkLockStatus;
	private _checkMouseShowTimer;
	private _exitPointerLockTimer;
	private _ignoreNextLock;
	private _ignoreTimer;
	exitPointerLock(time?: number): void;
	setSystemCursorShowStat(show: boolean): Promise<boolean>;
	private setLocalShow;
	private removeKeyUpListener;
	setSystemCursorShowStatControlKey(keyCode: string): void;
	setSystemCursorSensitivity(sensitivity: any): void;
	setSystemCursorShowStatManual(isManual: any): void;
	destroy(): void;
	_enhanceEscFunction(): void;
}
declare class TouchHandler {
	noScaleAndLandscape: boolean;
	noScale: boolean;
	eventStore: EventStore;
	touchSender: TouchSender;
	clickCount: number;
	hasVideoBlackPadding: boolean;
	_player: any;
	mode: MODE;
	domId: string;
	isPC?: boolean;
	disableInteraction?: boolean;
	enableLocalMouseScroll: boolean;
	disableDefaultTouchEvent: boolean;
	hasMouseScrollVirtualClick: boolean;
	mouseWheelDirectionFollowSystem: 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;
	systemCursorShowStatHandler: SystemCursorShowStatHandler;
	systemCursorHiddenVirtualPosition: {
		clientX: number;
		clientY: number;
	};
	private _videoRenderMode;
	private _isClickFlag?;
	resetMouseScroll: () => void;
	private mouseMoveInterval;
	private mouseMoveLastTriggerTime;
	private mouseMoveCacheData;
	constructor(player: any, { domId, mode, isPC, disableInteraction, enableLocalMouseScroll, localKeyboardHandler, systemCursorShowStatHandler, disableDefaultTouchEvent, mouseWheelDirectionFollowSystem, }: {
		domId: any;
		mode: any;
		isPC?: boolean;
		disableInteraction?: boolean;
		enableLocalMouseScroll?: boolean;
		localKeyboardHandler?: any;
		systemCursorShowStatHandler: any;
		disableDefaultTouchEvent: any;
		mouseWheelDirectionFollowSystem?: boolean;
	});
	get isCursorShow(): boolean;
	setMouseMoveInterval(interval: number): void;
	setDegree(degree: any): void;
	setRotation(rotation: any): void;
	_initEvent(): void;
	setStreamSize({ streamWidth, streamHeight }: {
		streamWidth: any;
		streamHeight: any;
	}): void;
	setContentSize({ width, height, enableScale }: {
		width: number;
		height: number;
		enableScale?: boolean;
	}): void;
	set videoRenderMode(renderMode: VIDEO_RENDER_MODE);
	get videoRenderMode(): VIDEO_RENDER_MODE;
	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;
	private _cachePos;
	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;
	mouseConvertPC({ event, action, width, height, offsetLeft, offsetTop }: {
		event: any;
		action: any;
		width: any;
		height: any;
		offsetLeft: any;
		offsetTop: any;
	}): ArrayBuffer | {
		op_type: number;
		event_data: {
			action: any;
			button: any;
			axis_v: any;
			axis_h: any;
			x: any;
			y: any;
		};
	};
	mouseConvertPCPB(event: MouseEvent): {
		absX: number;
		absY: number;
	};
	coordinateScaleAndRotate({ width, height, targetx, targety, podWidth, podHeight }: {
		width: any;
		height: any;
		targetx: any;
		targety: any;
		podWidth: any;
		podHeight: any;
	}): {
		x: number;
		y: number;
	};
	_sendKeyDown(keycode: any): void;
	keydown(event: any, force?: boolean): void;
	keyup(event: any, force?: boolean): void;
	clearPressedKey(): void;
	pasteEvent(event: any): void;
	_firstClickPlayAudio(): void;
	destroy(): void;
}
declare class LocalKeyboardHandler {
	inputCon: HTMLElement;
	_inputContainerDomId: string;
	private _player;
	private _inputDomId;
	private _customLocalKeyboardInputId;
	private _isFirstResponseRotation;
	private _inputMethodData;
	private _status;
	private _inputFocused;
	private _keydownFn;
	private _useCustomLocalKeyboardInput;
	private _inputComsitionStartListener;
	private _inputComsitionEndListener;
	private _inputInputListener;
	private _inputBlurListener;
	private _inputFocusListener;
	private _hasInitInputRelatedEvent;
	private _isVePhone;
	private composText;
	constructor(player: any, { customLocalKeyboardInputId, useCustomLocalKeyboardInput }: {
		customLocalKeyboardInputId: any;
		useCustomLocalKeyboardInput: any;
	});
	get status(): number;
	init(): any;
	private _sendKeyCustom;
	_initInputRelatedEvent(inputEle: any): void;
	_removeInputRelatedEvent(inputEle: any): void;
	setCustomLocalKeyboardInputId(customLocalKeyboardInputId: any): void;
	clearCustomLocalKeyboardInput(): void;
	inputFocus(): void;
	syncLocalKeyboardCloseStatus(): any;
	_getInputElement(): any;
	private onReceiveCurText;
	handleInputMethodEvent(msg: any): void;
	handleRotationEvent(msg: any): any;
	updateInputSelection(): void;
	reset(): void;
	destroy(): void;
}
declare class LocalKeyboardHandler {
	inputCon: HTMLElement;
	_inputContainerDomId: string;
	private _player;
	private _inputDomId;
	private _customLocalKeyboardInputId;
	private _isFirstResponseRotation;
	private _status;
	private _inputFocused;
	private composText;
	private touchElement;
	private currentText;
	private clientSelectAllText;
	private _isMac;
	constructor(player: any, { customLocalKeyboardInputId }: {
		customLocalKeyboardInputId: any;
	});
	get status(): number;
	init(): any;
	keydown: (event: any) => boolean;
	keyup: (event: any) => boolean;
	pasteEvent: (event: any) => void;
	mouseUp: (event: any) => void;
	inputFocus(): void;
	handleInputMethodEvent(msg: any): void;
	handleRotationEvent(msg: any): void;
	reset(): void;
	destroy(): void;
}
declare class VideoStreamProfileHandler {
	private _player;
	private _enabled;
	constructor(player: any);
	disabled(): void;
	switchVideoStreamProfile(id: number): Promise<{
		result: number;
		reason: string;
		before: string;
		after: string;
	}>;
	getVideoStreamProfile(): Promise<{
		result: number;
		reason: string;
		before: string;
		after: string;
	}>;
	_handleVideoStreamProfileEvent(msg: any): {
		callUserId: any;
		result: any;
		reason: string;
		before: any;
		after: any;
		fps: any;
		code: any;
	};
}
export interface IMsgOption {
	message: any;
	needAck?: boolean;
	timeout?: number;
	destUserId?: string;
	key?: string;
	useProxy?: boolean;
}
declare class VEMessageHandler {
	_player: Player;
	private _isMessageChannelOnline;
	private _time;
	private _isMessageChannelOnlineMap;
	private _msgSetTimeout;
	private _hasEmitChannelReadyEvent;
	private _mccKeyParser;
	private _msgProxy;
	private _msgChannelVersion;
	constructor(player: Player);
	private setIsOnline;
	initMap(): void;
	sendVEMessage({ message, needAck, timeout, destUserId, key, useProxy, }: IMsgOption): Promise<unknown>;
	receiveVEMessage(msg: any): {
		ackId: any;
	};
	receiveVEBinaryMessage(data: any): any;
	updateMessageChannelState({ destUserId, online }: {
		destUserId: any;
		online: any;
	}): void;
}
declare class ScreenLockHandler {
	_isRotation: boolean;
	private _player;
	private logger;
	private _domId;
	private containerDomId;
	private _isOrientation;
	private _rotation;
	private _clear;
	private _orientationchangeListener;
	constructor(player: any, { domId }: {
		domId: any;
	});
	_init(): void;
	handleScreenLock(isRotation?: boolean, rotation?: number): void;
	debounce(func: any, delay: any): () => void;
	destroy(): void;
}
declare class RTCEngine {
	isRTC: boolean;
	_userJoined: boolean;
	audioEle?: HTMLAudioElement;
	renderEle: HTMLVideoElement;
	_client: IRTCEngine;
	private _player;
	private _logger;
	private _userId;
	private _containerDomId;
	private _podUserId?;
	private _remoteStream?;
	private _rtcVideoEleId?;
	private _mute?;
	private _startMute?;
	private _reconnectTime?;
	private _sdkType?;
	private _expectedIDC?;
	private _muteState?;
	private _isAudioPublishStream?;
	private _isVideoPublishStream?;
	private _hasEmitAudioAutoWarning?;
	private _canEmitReconnectedEvent?;
	private _hasAddVisibilityChangeListener?;
	private status?;
	private _remoteUsers?;
	private _visibilityCallback?;
	private _invisible;
	private _scaleParams;
	private _remotePlayerDom;
	private isPlaying?;
	private _connectState?;
	private _stats?;
	private _reconnectInterId?;
	private _hasInvisible?;
	private _joinRoomTimeout;
	private _firstFrameRendered;
	static setDeviceId(did: string): void;
	constructor(player: Player, options: any);
	start({ roomId, token, podUserId, rtcAppId, width, height, mute, videoRenderMode, startTime, retry, gameType, disableAudioInjection, }: {
		roomId: any;
		token: any;
		podUserId: any;
		rtcAppId: any;
		width: any;
		height: any;
		mute: any;
		videoRenderMode: any;
		startTime: any;
		retry?: boolean;
		gameType?: string;
		disableAudioInjection: any;
	}): Promise<{
		width: string;
		height: string;
		streamWidth: string | number;
		streamHeight: string | number;
	}>;
	_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(): Promise<unknown>;
	sendMessage(message: any, isBinary: any): Promise<void>;
	initStats(): void;
	getStats(): Promise<{
		accessDelay: number;
		videoReceivedPacketsLostRate: number;
		videoReceivedBitrate: number;
		videoReceivedFrameRate: number;
		videoReceivedResolutionHeight: number;
		videoReceivedResolutionWidth: number;
	}>;
	private get isConnected();
	connectionStateMap(e: any): void;
	saveVisibleToHiddenStats(): void;
	restoreVisibleToHiddenStats(): void;
	getConnectionState(): string;
	play(reload?: boolean): Promise<void>;
	setAudioMute(mute: any): void;
	isAudioMuted(): boolean;
	muteStream(mute: {
		audio?: boolean;
		video?: boolean;
	}, type: string): void;
	private _initAudioPlayer;
	isVideoMuted(): boolean;
	setVideoMute(mute: boolean): void;
	unsubscribeStream(mediaType: any, successFn: any): Promise<void>;
	subscribeStream(mediaType: any, successFn: any): Promise<void>;
	pauseOrResume(isPause: any): void;
	_retryIsTimeOut(retry: any): void;
	_streamStop(): void;
	_removeClientListener(): void;
	_reconnect(time: any): void;
	_cancelReconnect(): void;
	_publishStream(streamType?: MediaType): Promise<unknown>;
	_unPublishStream(streamType?: MediaType): Promise<unknown>;
	updateVideoRenderMode(videoRenderMode: any): void;
	set reconnectTime(time: number);
	get reconnectTime(): number;
	get remoteStream(): any;
	get isReady(): boolean;
	destroy(): void;
	private initPauseDetect;
	setVolume(volume: number): void;
	getVolume(): number;
	startAudioRecord(): (onData: (url: any) => void) => void;
}
declare class DetectDelayHandler {
	private _player;
	private logger;
	private _detectDelayInterval;
	private _detectDelayInfo;
	private touchDelayDetector;
	paused: boolean;
	checkFrames: number;
	private _detectDelayCache;
	private rvfcHandler;
	private visibleHandler;
	constructor(player: any, { mode }: {
		mode: any;
	});
	injectCheckId(checkId: any, sendTime?: any): void;
	pause(pause?: boolean): void;
	start(interval?: number): void;
	setDetectInterval(interval: number): boolean;
	private _report;
	private _receiveDelayTestMessage;
	private _calcElapse;
	handleDetectDelayMessage(evt: any): any;
	stop(): void;
}
declare class ControlRightHandler {
	private _player;
	role: number;
	canOperate: boolean;
	constructor(player: any);
	get isPlayer(): boolean;
	get userId(): any;
	changeRole({ userId, role }: {
		userId: any;
		role: any;
	}): any;
	handleMessage(decodedMessage: any): boolean;
	_onReceivePlayers(players: any, fromUpdate: any): void;
	_setRole(role: any): void;
}
declare class PCImeHandler {
	private input;
	private inputContainer;
	_player: any;
	_lastClickPosition: {
		x: number;
		y: number;
	};
	inCompositionEvent: boolean;
	isPC: boolean;
	inInputMode: boolean;
	showInput: boolean;
	renderEle: any;
	get isInComposition(): boolean;
	constructor(player: any);
	needSendKey(e: any, isDown?: boolean): boolean;
	_setInputVisible(bool: any): void;
	_setInputContainerVisible(bool: any): void;
	_createInput(): HTMLTextAreaElement;
	_createPCInput(): HTMLTextAreaElement;
	_createH5InputContainer(): HTMLTextAreaElement;
	_handleCompleteButtonClick(): void;
	init(renderEle: any): void;
	_initPCEvent(input: any, renderEle: any): void;
	_initH5Event(input: any, renderEle: any): void;
	sendText(text: string): void;
	enterInputMode(): void;
	sendImeMessage(type: any, str?: string): void;
	handleMessage(decodedMessage: any): boolean;
	setInputVisible(bool: any, style: any): 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;
export interface ISupportBoolean {
	rtcSupport: boolean;
	socketSupport: boolean;
}
declare function isSocketSupported(): boolean;
declare function isRtcSupported(): Promise<boolean>;
declare function isSupportedStatic(): Promise<ISupportBoolean>;
declare function isSupported(this: Player): Promise<ISupportBoolean>;
declare function orientationChange(onchange: (orientation: 0 | 90 | -90, reason: "orientationchange" | "resize") => void): () => 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
}
export interface ControlState {
	userId: string;
	enable: boolean;
}
export interface ControlEventResult {
	code: 0 | -1;
	msg?: string;
	data?: ControlState;
}
declare class VePhoneControlRightHandler {
	canOperate: boolean;
	private _player;
	private currentUserId;
	private _isInnerInvokeHasControl?;
	constructor(player: Player);
	start(): void;
	private _promisifyEventCallback;
	enableControl(userId: string, enable: boolean): Promise<ControlEventResult>;
	_innerHasControl(): Promise<ControlEventResult>;
	hasControl(userId: string): Promise<ControlEventResult>;
	getAllControls(): Promise<Omit<ControlEventResult, "data"> & {
		data?: ControlState[];
	}>;
	private _initControlListener;
}
declare class HandlerCore 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 function CheckUASupport({ token, gameHost, logger, }: {
	token: STSToken;
	gameHost?: string;
	logger?: any;
}): Promise<boolean>;
declare class RemoteLogger {
	private commonParams;
	once: EmitterMethod;
	on: EmitterMethod;
	off: EmitterMethod;
	emit: (type: string, ...args: any[]) => void;
	userId: string;
	startEventTime: any;
	teaLog: Tea;
	constructor(options: any);
	setCommonParams(params: any): void;
	setSingleParam(key: any, value: any): void;
	getTeaCommonHeaders(): {
		device_model: string;
		os_version: string;
		browser: string;
		browser_version: string;
		os_name: string;
	} & Record<string, any>;
	getCommonParams(): Record<string, any> | {
		accountId: string;
		volcProduct: "veGame" | "vePhone";
		initSessionId: string;
		sessionId: string;
		uuid: string;
	};
	send(eventName: any, rawData: {}, oldData: any): void;
	sendWithDIYName(eventName: any, rawData?: {}): void;
	beaconSend(eventName: any, 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 class ApiHubCommon extends HandlerCore {
	options: CloudCoreConfig;
	logger: Logger;
	static checkUASupport(params: Parameters<typeof CheckUASupport>[0]): Promise<boolean>;
	CheckUASupport(token: STSToken): Promise<boolean>;
}
declare enum FileChannelP2PAction {
	SendFile = 0,
	SendFileAck = 1,
	SliceData = 2,
	SlicesAck = 3,
	FileFinished = 4,
	RequestSlice = 5,
	ReceiveFinished = 6,
	Cancel = 7
}
declare enum FileChannelP2PResult {
	Success = 0,
	Canceled = 1,
	Failed = -1000,
	FileNotExist = -999,
	TransprtBusy = -998,
	TimeOut = -997,
	eFileTooLarge = -996
}
export interface FileInfo {
	file_name: string;
	json_option: string;
	file_size: number;
	file_md5: string;
	slice_size: number;
}
export interface SliceData {
	slice_index: number;
	data: Uint8Array;
}
export interface TransferState {
	transferId: string;
	fileName: string;
	fileSize: number;
	fileMd5: string;
	sliceSize: number;
	jsonOption: string;
	totalSlices: number;
	startTime: number;
	status: "receiving" | "complete" | "failed" | "cancelled";
}
export interface TransferStats {
	totalSlices: number;
	receivedSlices: number;
	missingSlices: number;
	startTime: number;
	lastSliceTime: number;
}
export interface TransferContext {
	state: TransferState;
	receivedSlices: Set<number>;
	fileData: Map<number, Uint8Array>;
	stats: TransferStats;
}
export interface BusinessFileChannelP2PMessage {
	action: FileChannelP2PAction;
	result?: FileChannelP2PResult;
	transfer_id: string;
	file_info?: FileInfo;
	slice_data?: SliceData;
	slices?: number[];
	slices_time?: number;
}
declare class FileChannelP2PReceiveHandler {
	private player;
	private transfers;
	private timeoutTimers;
	private readonly TIMEOUT_DURATION;
	constructor(player: Player);
	emitEvent(event: string, ...data: any[]): void;
	log(event: string, data: any): void;
	getTransferContext(transfer_id: string): TransferContext | undefined;
	handleBusinessFileChannelP2PMessage(message: BusinessFileChannelP2PMessage): void;
	onReceiveSendFileAction(data: {
		transfer_id: string;
		file_info: FileInfo;
	}): void;
	onReceiveSliceDataAction(data: {
		transfer_id: string;
		slice_data?: SliceData;
		slices_time?: number;
		slices?: number[];
	}): void;
	onReceiveFileFinishAction(data: {
		transfer_id: string;
		result: FileChannelP2PResult;
	}): void;
	onReceiveCancelSendFileAction(data: {
		transfer_id: string;
		result: FileChannelP2PResult;
	}): void;
	private finalizeFileTransfer;
	private getMissingSlices;
	private setTransferTimeout;
	private clearTransferTimeout;
	private cleanupTransfer;
	private sendMessage;
	private sendSendFileAck;
	private sendSliceAck;
	private sendRequestSlice;
	private sendReceiveFinished;
	destroy(): void;
}
export declare type BlobLike = Blob | File;
declare class FileChannelP2PSenderHandler {
	private player;
	private running;
	private file;
	private sliceSize;
	private transferId;
	private sliceCount;
	private sliceOffset;
	private retrySlices;
	private sendSlices;
	private needAckSlices;
	private sendClearTimeMs;
	private needAckTimeMs;
	private bSlicedAcked;
	private mSleepMs;
	private retryCount;
	private transferStartTimeMs;
	private delayCtrl;
	private fileInfo;
	private state;
	private readonly MAX_FILE_SIZE;
	private readonly INITIAL_ACK_TIMEOUT;
	private readonly SLICE_ACK_TIMEOUT;
	private readonly TOTAL_ACK_TIMEOUT;
	private readonly FINISH_ACK_TIMEOUT;
	private readonly BATCH_ACK_THRESHOLD;
	private activeTimers;
	constructor(player: Player);
	private createEventData;
	private createErrorData;
	emitEvent(event: string, ...data: any[]): void;
	log(event: string, data: any): void;
	private sendMessage;
	private sleep;
	private setTimeout;
	private clearAllTimers;
	private getSendSliceType;
	private readSlice;
	private sendStart;
	private sendSlice;
	private sendFileFinished;
	private sendCancel;
	startSendFile(file: BlobLike, options?: {
		jsonOption?: string;
		name?: string;
		sliceSize?: number;
	}): Promise<boolean>;
	private sendLoop;
	private sendNextSlice;
	private getNextSliceIndex;
	private shouldWaitForAck;
	private isAllSlicesSent;
	private waitForAckIfNeeded;
	private handleAckTimeout;
	private logAckTimeout;
	private logAckRetry;
	private failWithError;
	private updateSendProgress;
	private waitForFinalAck;
	private logFinishTimeout;
	private handleFinalResult;
	private handleRetryNeeded;
	private completeTransfer;
	private stateIsTransferring;
	private stateIsFinishedOrRetrying;
	private waitFor;
	handleBusinessFileChannelP2PMessage(message: BusinessFileChannelP2PMessage): void;
	private handleSendFileAck;
	private handleSlicesAck;
	private handleRequestSlice;
	private handleReceiveFinished;
	private handleCancel;
	private resetState;
	stopSendFile(): boolean;
}
export declare class Player extends ApiHubCommon {
	static MODE: typeof MODE;
	static ACTION: typeof ACTION;
	static KEYCODE: typeof KEYCODE;
	static MOUSE_BUTTON: typeof MOUSE_BUTTON;
	static GAMEPAD_BUTTON: {
		KEYCODE_BUTTON_A: number;
		KEYCODE_BUTTON_B: number;
		KEYCODE_BUTTON_X: number;
		KEYCODE_BUTTON_Y: number;
		KEYCODE_BUTTON_START: number;
		KEYCODE_BUTTON_SELECT: number;
		KEYCODE_BUTTON_L1: number;
		KEYCODE_BUTTON_R1: number;
		KEYCODE_BUTTON_L2: number;
		KEYCODE_BUTTON_R2: number;
		KEYCODE_BUTTON_THUMBL: number;
		KEYCODE_BUTTON_THUMBR: number;
		KEYCODE_DPAD_UP: number;
		KEYCODE_DPAD_DOWN: number;
		KEYCODE_DPAD_LEFT: number;
		KEYCODE_DPAD_RIGHT: number;
		KEYCODE_DPAD_UP_LEFT: number;
		KEYCODE_DPAD_DOWN_LEFT: number;
		KEYCODE_DPAD_UP_RIGHT: number;
		KEYCODE_DPAD_DOWN_RIGHT: number;
	};
	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[];
	userId: string;
	domId: string;
	customLocalKeyboardInputId: string;
	useCustomLocalKeyboardInput: boolean;
	region: string;
	mode: MODE;
	isVePhone?: boolean;
	isPC?: boolean;
	disableInteraction?: boolean;
	getResourceHost?: string;
	gameHost?: string;
	clientMode: unknown;
	phoneHost?: string;
	accountId: string;
	private localStream;
	status: string;
	_debug?: boolean;
	_keyCodeList: number[];
	did: string;
	rotationMode?: string;
	private uiDomRotation?;
	private rotationDegree?;
	isPodLxc?: boolean;
	_destroyed: boolean;
	_controlRightHandler: ControlRightHandler | VePhoneControlRightHandler;
	_systemCursorShowStatHandler: SystemCursorShowStatHandler;
	_uesLocalKeyboard?: boolean;
	_mediaProvider?: string;
	containerDomId: string;
	_cacheToken: STSToken;
	_reservedId?: string;
	touchHandler: TouchHandler;
	private _commonHandler;
	_videoStreamProfileHandler: VideoStreamProfileHandler;
	private _backgroundHandler;
	private _autoRecycleTimeHandler?;
	private _userProfilePathHandler?;
	_veMessageHandler?: VEMessageHandler;
	protected _localKeyboardHandler: LocalKeyboardHandler | LocalKeyboardExtendHandler;
	protected _pcImeHandler: PCImeHandler;
	private _locationServiceHandler;
	private _remoteAppBackgroundHandler;
	private _clipboardHandler;
	private _clipboardAutoSyncHandler;
	private _fullscreenHandler;
	private _startWithFrameworkHandler;
	_detectDelayHandler: DetectDelayHandler;
	private _screenRecordHandler;
	_keyboardDisableHandler: KeyboardDisableHandler;
	_networkHandler: NetworkHandler;
	client: RTCEngine;
	private _localAudioHandler;
	private _localCameraHandler;
	private _screenShotHandler;
	_screenLockHandler: ScreenLockHandler;
	_isSocketSupport: boolean;
	sessionId: string;
	_needFirstClickPlayAudio: boolean;
	_isRotationGameService: boolean;
	sessionIdState: "start" | "stop";
	podUserId: string;
	_rtc_business_id: string;
	_skey: unknown;
	remoteMessager: unknown;
	_gameId: string;
	mcc: boolean;
	_fileChannelP2PReceiveHandler: FileChannelP2PReceiveHandler;
	_fileChannelP2PSenderHandler: FileChannelP2PSenderHandler;
	get config(): ICGConfig;
	isAccountIdHit(accountIds?: string): boolean;
	_podId?: string;
	_remoteWindowSize?: {
		width: number;
		height: number;
	};
	private _removeResizeMonitor;
	private lastTouchTime;
	private _isClusterControl;
	_isAutoRefreshToken: boolean;
	emit: (type: string, ...args: any[]) => void;
	once: EmitterMethod;
	on: EmitterMethod;
	off: EmitterMethod;
	_isHaiMACloud: boolean;
	startPromise: Promise<{
		width: number;
		height: number;
	}>;
	private _starter;
	constructor(options: CloudCoreConfig);
	private _constructor;
	private initCoreHandlers;
	get usePB(): boolean;
	set usePB(v: boolean);
	get canOperate(): boolean;
	static isSupported: typeof isSupportedStatic;
	static isSocketSupported: typeof isSocketSupported;
	static isRtcSupported: typeof isRtcSupported;
	static isWebTSSupported: () => any;
	static isH265Supported: () => Promise<any>;
	_isSupported: typeof isSupported;
	_setOptions(options: CloudCoreConfig): void;
	private _setUserId;
	get originUserId(): string;
	_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: any): number;
	_getLocalAudioPlaybackVolume(): number;
	_setAutoRecycleTime(duration: any): Promise<void>;
	_getAutoRecycleTime(): Promise<{
		time: number;
	}>;
	_setUserProfilePath(pathList: any): Promise<void>;
	_getUserProfilePath(): Promise<any>;
	_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;
	_playByInteraction(reload?: boolean): Promise<void>;
	_touchRotation(rotation?: string | number, gameType?: string): void;
	_stop(isUserStop?: boolean, renewSid?: boolean): Promise<void>;
	_pauseOrResume(isPause?: boolean): void;
	_renewToken(token: STSToken): void;
	_renewSessionId(): void;
	_updateVideoScale(): void;
	_rotateCoordinate(degree: number): void;
	_rotateScreen(degree: number, isPodRotate?: boolean): void;
	_rotateVideoParentDom(degree: number): boolean;
	_sendRotateEventToGame(rotation: number, duration?: number): Promise<void>;
	_rotate(degree: number): void;
	_setAudioMute(mute: boolean): void;
	_muteAudio(mute: boolean): void;
	_isAudioMuted(): boolean;
	_muteVideo(mute: boolean): void;
	_isVideoMuted(): boolean;
	_getStats(): Promise<{}>;
	_getConnectionState(): string;
	_getDeviceId(): string;
	getResourceStatus(): Promise<string>;
	getVePhonePodStatus(): Promise<{
		podStatus: PodStatus;
	}>;
	updateMediaToken(): 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, useProxy, }: {
		message: ArrayBuffer | string;
		needAck?: boolean;
		timeout?: number;
		destUserId?: string;
		key?: string;
		useProxy?: boolean;
	}): Promise<unknown>;
	_sendClipBoardMessage(text: string): Promise<any>;
	_sendCustomMessage(customMessage: Record<string, any> | ArrayBufferLike): Promise<any>;
	_sendMessage(message: string | any, isBinary?: boolean): Promise<void> | Promise<{
		error: any;
		message: any;
		isBinary: boolean;
	}>;
	_sendCustomMessageWithReturn(data: IMessageReturnOptions): Promise<{
		success: boolean;
		data: any;
		fromCatch?: boolean;
		err?: 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;
	}): Promise<unknown>;
	_sendGamepadButtonMessage({ keycode, action, index, }: {
		keycode: number;
		action: number;
		index?: number;
	}): Promise<any>;
	_sendJoystickMessage({ leftX, leftY, rightX, rightY, leftT, rightT, index, }: {
		leftX: number;
		leftY: number;
		rightX: number;
		rightY: number;
		leftT: number;
		rightT: number;
		index?: number;
	}): void;
	_sendGamePadPbMessage(payload?: {}): Promise<void> | Promise<{
		error: any;
		message: any;
		isBinary: boolean;
	}>;
	_enableLocalAudio(): Promise<void>;
	_disableLocalAudio(): Promise<void>;
	messageReceivedHandler(event: {
		message: string;
	}, userId?: string): void;
	_onReceiveBusinessMessage(subtype: number, msg: any): boolean;
	_onReceiveIMEMessage(subtype: number, msg: any): boolean;
	binaryMessageReceviedHandler(event: {
		message: ArrayBuffer;
	}, userId?: string): void;
	seiMessageReceviedHandler(event: any, userId: string): any;
	_switchVideoStreamProfile(id: number): Promise<{
		result: number;
		reason: string;
		before: string;
		after: string;
	}>;
	_getVideoStreamProfile(): Promise<{
		result: number;
		reason: string;
		before: string;
		after: string;
	}>;
	_switchBackground(on: boolean): Promise<unknown>;
	_setFullScreenState(state: boolean, { fitMode, }: {
		fitMode: string;
	}): void;
	_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(): void;
	_getAudioPlaybackDeviceList(): Promise<MediaDeviceInfo[]>;
	_setAudioPlaybackRoute(deviceId: string): void;
	_getAudioCaptureDeviceList(): Promise<MediaDeviceInfo[]>;
	_setAudioCaptureDevice(deviceId: string): Promise<unknown>;
	_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(): any;
	_setVideoCaptureDevice(deviceId: string): Promise<unknown>;
	_getVideoPlaybackDeviceList(): Promise<MediaDeviceInfo[]>;
	_getVideoCaptureDevice(): string;
	_setLocalVideoView(options: {
		streamIndex: number;
		videoPlayerOption: Partial<VideoPlayerOption>;
	}): HTMLVideoElement | undefined;
	_setVideoRotationMode(options: unknown): any;
	_setLocalVideoMirrorMode(mirrorType: number): void;
	_getLocalVideoMirrorMode(): number;
	_setVideoCaptureConfig(config: {
		width?: string;
		height?: string;
		facingMode?: string;
	}): 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;
	_screenShot(isSavedOnPod: boolean): Promise<{
		result: any;
		savePath: any;
		message: string;
		downloadUrl: string;
	}>;
	_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;
	_setSystemCursorShowStatControlKey(keyCode: string): void;
	_setSystemCursorShowStat(show: boolean): Promise<boolean>;
	_setSystemCursorSensitivity(sensitivity: number): void;
	_updateVideoRenderMode(videoRenderMode: number): void;
	_destroyHandler(): void;
	_destroy(): Promise<boolean>;
	_changeRole(data: {
		userId: string;
		role: 0 | 1;
	}): any;
	_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>;
	_enableFullScreen(enable: boolean): Promise<unknown>;
	_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;
	cancelQueue(): Promise<boolean>;
	startAudioRecord(): (onData: (url: any) => void) => void;
	_start(options: CoreStartConfig): Promise<CoreStartSuccessReturn>;
	_restart(): Promise<number>;
	_startRTC(options: StartRTCOptions): Promise<{
		width: string;
		height: string;
	}>;
	_startSocket(options: StartSocketConfig): Promise<{
		width: string | number;
		height: string | number;
		roundId: string;
		extra?: Record<string, string>;
	}>;
	_retryInitAndStart(): Promise<void>;
	_kuluoGenerateSolutionMessage(params: {
		deviceWidth: number;
		deviceHeight: number;
	}): Promise<{
		resolutionWidth: any;
		resolutionHeight: any;
	}>;
}
export declare class ApiHubGame extends Player {
	exitPointerLock(time?: number): void;
	isSuperResolutionSupport(): any;
	setSRParam(config: Partial<ISuperResolutionOptions["config"]>): void;
	getNodeList({ token, timeout, }: {
		token: STSToken;
		timeout?: number;
	}): Promise<{
		nodeResult: {
			lineId: string;
			nodeAlias: string;
			nodeId: string;
			nodeName: string;
			pingResult: number;
			provide: string;
			type: string;
		}[];
	}>;
	control: {
		setCanOprate: (bool: any) => void;
	};
}

export {
	Player as default,
};

export {};