larksr_websdk 3.2.0

package/dist/types/lark/application.d.ts

@@ -0,0 +1,102 @@
+import { EventBase, LocalEvent } from '../event/event_base';
+import * as Msg from '../protobuf/cloudlark';
+import WebSocektChannel from './websocket_channel';
+import WebsocketProxy from './websocket_proxy';
+import { LarkSR } from '../larksr';
+export declare enum APP_STATE {
+    BEFORE_CREATE = 0,
+    INITED = 1,
+    WEBSOCKET_CHANNEL_OPEN = 2,
+    LOGIN_SUCCESS = 3,
+    RTC_CONNECTED = 4,
+    MEDIA_LOADED = 5,
+    MEDIA_PLAED = 6,
+    RTC_RETRY = 7,
+    APP_RETRY = 8,
+    BEFORE_DESTORY = 9,
+    WEBSOCKET_CLOSED = 10,
+    RTC_CLOSED = 11,
+    DESTROYED = 12
+}
+export declare enum APP_EVENT_TYPE {
+    REMOTE_STREAM = 0,
+    SYNC_CURSORSTYLE = 1,
+    APP_STATE_CHANGE = 2,
+    LK_APP_RESIZE = 3,
+    LK_APP_MOUSE_MODE = 4,
+    LK_APP_PLAER_LIST = 5,
+    LK_APP_REQUEST_TEXT = 6,
+    LK_DATA_CHANNEL_RENDERSERVER_TEXT_MESSAGE = 7,
+    LK_DATA_CHANNEL_RENDERSERVER_BINARY_MESSAGE = 8,
+    LK_DATA_CHANNEL_RENDERSERVER_OPEN = 9,
+    LK_DATA_CHANNEL_RENDERSERVER_CLOSE = 10
+}
+export interface AppEvent extends LocalEvent<APP_EVENT_TYPE> {
+    data?: any;
+    state: APP_STATE;
+}
+export default class Application extends EventBase<APP_EVENT_TYPE, AppEvent> {
+    private websocketChannel;
+    private websocketProxy;
+    private peerConnection;
+    get state(): APP_STATE;
+    set state(state: APP_STATE);
+    private _state;
+    private retryTime;
+    private larksr;
+    constructor(larksr: LarkSR);
+    init(): void;
+    initPc(): void;
+    releasePc(): void;
+    clear(): void;
+    changeOperater(uid: number): void;
+    inputText(text: string): void;
+    sendTextToDataChannel(text: string): void;
+    sendBinaryToDataChannel(binary: Uint8Array): void;
+    start(): Promise<void>;
+    connect(): Promise<WebsocketProxy> | Promise<WebSocektChannel> | undefined;
+    disConnect(): void;
+    closeRtc(): void;
+    versionCheck(): void;
+    task(): void;
+    startSteam(): void;
+    startMonitorSteam(): void;
+    restart(): void;
+    restartApp(): void;
+    rtcOffer(): void;
+    setAnswer(sdp: string): void;
+    setIce(candidate: string): void;
+    sendInput(input: Msg.CloudLark.ClientInput): void;
+    private onChannelOpen;
+    private onClose;
+    private onChannelMsg;
+    private onVersionCheckResponse;
+    private onTaskResponse;
+    private onStartStreamResponse;
+    private onStartMonitorResponse;
+    private onWebRtcOfferAnswer;
+    private onWebRtcIcecandidate;
+    private onWebRtcError;
+    private onAppProcess;
+    private onLogout;
+    private onLocalSdp;
+    private onLoacalIce;
+    private onRemoteStream;
+    private onRtcError;
+    private onIceStateChange;
+    retryPeerconnection(): void;
+    private onPeerConnectionDisconnect;
+    private onBadNetwork;
+    private onCursorStyle;
+    private onAppResize;
+    private onAppMouseMode;
+    private onAppPlayerList;
+    private onAppRequestText;
+    private onDataChannelText;
+    private onDataChannelBinary;
+    private onDataChannelOpen;
+    private onDataChannelClose;
+    appStateChange(state: APP_STATE): void;
+    private $emit;
+    private createAppEvent;
+}

package/dist/types/lark/custom.d.ts

@@ -0,0 +1,7 @@
+declare module "worker-loader!*" {
+  class WebpackWorker extends Worker {
+    constructor();
+  }
+
+  export = WebpackWorker;
+}

package/dist/types/lark/lark_event_type.d.ts

@@ -0,0 +1,109 @@
+export declare const enum LarkEventType {
+    LK_WEB_CLIENT_LOAD_SUCCESS = 1,
+    LK_API_ENTERAPPLI_SUCCESS = 10,
+    LK_API_ENTERAPPLI_FAILED = 11,
+    LK_TASK_SYNC_APP = 20,
+    LK_TASK_SYNC_APP_FAILED = 21,
+    LK_RENDER_SERVER_CONNECTED = 100,
+    LK_RENDER_SERVER_FAILED = 101,
+    LK_RENDER_SERVER_CLOSE = 102,
+    LK_RENDER_SERVER_ERROR = 103,
+    LK_PROXY_SERVER_CONNECTED = 200,
+    LK_PROXY_SERVER_FAILED = 201,
+    LK_PROXY_SERVER_CLOSE = 202,
+    LK_PROXY_SERVER_ERROR = 203,
+    LK_VERSION_CHECK_SUCCESS = 300,
+    LK_VERSION_CHECK_FAILED = 301,
+    LK_TASK_SUCCESS = 400,
+    LK_TASK_NOTFOUND = 401,
+    LK_TASK_SERVER_ERROR = 402,
+    LK_TASK_APP_WRONGPARAM = 403,
+    LK_TASK_NO_GPU_RESOURCE = 404,
+    LK_START_STREAM_SUCCESS = 500,
+    LK_START_STREAM_PROCESS_START_FAILED = 501,
+    LK_START_STREAM_PROCESS_START_TIMEOUT = 502,
+    LK_START_STREAM_NOT_STREAMING = 503,
+    LK_START_STREAM_ENCODER_ERROR = 504,
+    LK_RTC_EVENT_PEERCONNECTION_CONNECTED = 600,
+    LK_RTC_EVENT_PEERCONNECTION_CLOSED = 601,
+    LK_RTC_EVENT_PEERCONNECTION_ERROR = 602,
+    LK_RTC_EVENT_PEERCONNECTION_STATE = 610,
+    LK_RTC_EVENT_PEERCONNECTION_RETRY = 611,
+    LK_VIDEO_LOADED = 700,
+    LK_VIDEO_PLAY_FAILED = 701,
+    LK_GOT_REMOTE_STREAM = 710,
+    LK_NOTIFY_CLIENT_LOGOUT_PLAYER_LOGOUT = 800,
+    LK_NOTIFY_CLIENT_LOGOUT_TASKOWNER_LOGOUT = 801,
+    LK_APP_PROCESS_NOTIFI_APP_QUIT = 900,
+    LK_NO_OPERATION_TIMEOUT = 901,
+    LK_LOADING_TIMEOUT = 902,
+    LK_APP_RESIZE = 910,
+    LK_APP_MOUSE_MODE = 911,
+    LK_APP_PLAER_LIST = 912,
+    LK_APP_REQUEST_TEXT = 913,
+    LK_APP_CURSOR_STYLE = 914,
+    LK_USER_REQUEST_QUIT = 920,
+    LK_UI_RESIZE = 930,
+    LK_STARTVRSTREAM_SUCCESS = 1000,
+    LK_STARTVRSTREAM_START_PROCESS_FAILED = 1001,
+    LK_STARTVRSTREAM_START_DRIVER_RUNTIME_TIMEOUT = 1002,
+    LK_STARTVRSTREAM_START_DRIVER_RUNTIME_UDPPORT_ERROR = 1003,
+    LK_STARTVRSTREAM_START_DRIVER_RUNTIME_ENCODER_ERROR = 1004,
+    LK_WEBCLIENT_NOTIFY_ALERT = 1100,
+    LK_WEBCLIENT_NOTIFY_CONFIRM = 1101,
+    LK_WEBCLIENT_TOAST_MSG = 1102,
+    LK_USER_CAPTURE_FRAME = 2000,
+    LK_USER_CAPTURE_FRAME_WITH_EXTRA_DATA = 2001,
+    LK_REQUEST_CAPTURE_FRAME = 3000,
+    LK_REQUEST_CAPTURE_FRAME_WITH_EXTRA_DATA = 3001,
+    LK_IFRAME_POSTER_OPERATE_MOUSE_MOVE = 10000,
+    LK_IFRAME_POSTER_OPERATE_MOUSE_DOWN = 10001,
+    LK_IFRAME_POSTER_OPERATE_MOUSE_UP = 10002,
+    LK_IFRAME_POSTER_OPERATE_MOUSE_WHEEL = 10003,
+    LK_IFRAME_POSTER_OPERATE_KEY_DOWN = 10010,
+    LK_IFRAME_POSTER_OPERATE_KEY_UP = 10011,
+    LK_IFRAME_POSTER_OPERATE_TOUCH_DOWN = 10020,
+    LK_IFRAME_POSTER_OPERATE_TOUCH_MOVE = 10021,
+    LK_IFRAME_POSTER_OPERATE_TOUCH_UP = 10022,
+    LK_IFRAME_POSTER_OPERATE_GAMEPAD_BUTTON_DOWN = 10030,
+    LK_IFRAME_POSTER_OPERATE_GAMEPAD_BUTTON_UP = 10031,
+    LK_IFRAME_POSTER_OPERATE_GAMEPAD_TRIGGER_VALUE = 10032,
+    LK_IFRAME_POSTER_OPERATE_GAMEPAD_JOYSTICK_STATES = 10033,
+    LK_IFRAME_POSTER_FUNC_MOUSE_MODE = 10100,
+    LK_IFRAME_POSTER_FUNC_SCALE_MODE = 10101,
+    LK_IFRAME_POSTER_FUNC_RESTART_CLOUD_APP = 10102,
+    LK_IFRAME_POSTER_FUNC_WX_JS_BRIDGE_READY = 10103,
+    LK_IFRAME_POSTER_FUNC_REQUEST_PLAY_VIDEO = 10104,
+    LK_IFRAME_POSTER_UI_CONTROLLER_BAR = 10200,
+    LK_IFRAME_POSTER_UI_PLAYER_LIST = 10201,
+    LK_IFRAME_POSTER_UI_PLAYER_SHARE_URL = 10202,
+    LK_IFRAME_POSTER_UI_MOBILE_CONTROL_BALL = 10203,
+    LK_IFRMAE_POSTER_UI_MOBILE_JOYSTICK = 10204,
+    LK_IFRAME_POSTER_UI_MOBILE_VIRTUAL_KEYBOARD = 10205,
+    LK_IFRAME_POSTER_UI_MOBILE_VIRTUAL_MOUSE = 10206,
+    LK_IFRAME_POSTER_UI_MOBILE_MENU = 10207,
+    LK_IFRAME_POSTER_UI_MOBILE_FORCE_LANDSCAPE = 10208,
+    LK_IFRAME_POSTER_UI_MOBILE_TOUCH_POINT = 10209,
+    LK_IFRAME_POSTER_UI_TOAST_LEVEL = 10210,
+    LK_IFRAME_POSTER_UI_ALERT = 10211,
+    LK_IFRAME_POSTER_UI_CONFIRM = 10212,
+    LK_DATA_CHANNEL_ESTABLISHED = 20000,
+    LK_DATA_CHANNEL_RETYING = 20001,
+    LK_DATA_CHANNEL_CLOSE = 20002,
+    LK_DATA_CHANNEL_ERROR = 20003,
+    LK_DATA_CHANNEL_BINARY_MESSAGE = 20004,
+    LK_DATA_CHANNEL_TEXT_MESSAGE = 20005,
+    LK_RE_CONNECT_DATA_CHANNEL = 20100,
+    LK_CLOSE_DATA_CHANNEL = 20101,
+    LK_DATA_CHANNEL_SEND_TEXT = 20102,
+    LK_DATA_CHANNEL_SEND_BINARY = 20103,
+    LK_DATA_CHANNEL_RENDERSERVER_OPEN = 20200,
+    LK_DATA_CHANNEL_RENDERSERVER_CLOSE = 20201,
+    LK_DATA_CHANNEL_RENDERSERVER_BINARY_MESSAGE = 20202,
+    LK_DATA_CHANNEL_RENDERSERVER_TEXT_MESSAGE = 20203,
+    LK_DATA_CHANNEL_RENDERSERVER_SEND_TEXT = 20300,
+    LK_DATA_CHANNEL_RENDERSERVER_SEND_BINARY = 20301
+}
+export default class LarkEvent {
+    static GetEventMessageByType(type: LarkEventType): string;
+}

package/dist/types/lark/message.d.ts

@@ -0,0 +1,19 @@
+import * as Msg from '../protobuf/cloudlark';
+import { LarkEventType } from './lark_event_type';
+export declare const MESSAGE_MAGIC = 538317090;
+export default class Message {
+    static emptyMsg(): Msg.CloudLark.ToServerMessage;
+    static versionCheckRequest(): Msg.CloudLark.ToServerMessage;
+    static taskRequest(taskid: string, isInteractiveMode: boolean, isObMode: boolean, nickName: string): Msg.CloudLark.ToServerMessage;
+    static startStreamReqeuest(request: Msg.CloudLark.IStartStreamRequest): Msg.CloudLark.ToServerMessage;
+    static startMonitorStreamReqeuest(request: Msg.CloudLark.IVrMonitorRequest): Msg.CloudLark.ToServerMessage;
+    static rtcOfferMsg(type: string, sdp: string): Msg.CloudLark.ToServerMessage;
+    static iceMsg(sdpmid: string, sdpMlineindex: number, candidate: string): Msg.CloudLark.ToServerMessage;
+    static restartApp(): Msg.CloudLark.ToServerMessage;
+    static getTaskResponseMsg(ressponse: Msg.CloudLark.TaskResponse.Response): string;
+    static getStartStreamResponseMsg(ressponse: Msg.CloudLark.StartStreamResponse.Response): string;
+    static getCloudlarkTaskEvent(ressponse: Msg.CloudLark.TaskResponse.Response): LarkEventType;
+    static getCloudlarkStartStreamEvent(ressponse: Msg.CloudLark.StartStreamResponse.Response): LarkEventType;
+    static getCloudlarkTaskEventMsg(type: LarkEventType): string;
+    static getCloudlarkStartStreamingEventMsg(type: LarkEventType): string;
+}

package/dist/types/lark/peer_connection.d.ts

@@ -0,0 +1,113 @@
+import { EventBase, LocalEvent } from '../event/event_base';
+import * as Input from '../protobuf/cloudlark';
+import { LarkSR } from '../larksr';
+export declare enum IceState {
+    DISCONNECT = 1,
+    BAD = 2,
+    CONNECT = 3,
+    GOOD = 4
+}
+export declare enum WEBRTC_EVENT_TYPE {
+    GOT_REMOTE_STREAM = 0,
+    ICE_STATE_CHANGE = 1,
+    LK_APP_RESIZE = 2,
+    LK_APP_MOUSE_MODE = 3,
+    LK_APP_PLAER_LIST = 4,
+    LK_APP_REQUEST_TEXT = 5,
+    LK_DATA_CHANNEL_RENDERSERVER_TEXT_MESSAGE = 6,
+    LK_DATA_CHANNEL_RENDERSERVER_BINARY_MESSAGE = 7,
+    LK_DATA_CHANNEL_RENDERSERVER_OPEN = 8,
+    LK_DATA_CHANNEL_RENDERSERVER_CLOSE = 9,
+    NET_STATE = 10,
+    SYNC_CURSORSTYLE = 11,
+    BAD_NETWORK = 12,
+    ERROR = 13,
+    RTC_SDP = 14,
+    RTC_ICECANDIDATE = 15
+}
+export interface GoogleBitRate {
+    start: number;
+    min: number;
+    max: number;
+}
+export interface WebRTCEvent extends LocalEvent<WEBRTC_EVENT_TYPE> {
+    data?: any;
+}
+export declare enum OfferModeType {
+    VP8 = 1,
+    VP9 = 2,
+    H264 = 3,
+    DEFAULT = 4
+}
+export interface WebRTCConfig {
+    serverIP: string;
+    preferPubOutIp: string;
+    codeRate?: number;
+    network: 'local' | 'public';
+}
+export interface AggregatedStats {
+    timestamp: number;
+    bytesReceived: number;
+    framesDecoded: number;
+    packetsLost: number;
+    bytesReceivedStart: number;
+    framesDecodedStart: number;
+    timestampStart: number;
+    bitrate: number;
+    lowBitrate: number;
+    highBitrate: number;
+    avgBitrate: number;
+    framerate: number;
+    lowFramerate: number;
+    highFramerate: number;
+    avgframerate: number;
+    framesDropped: number;
+    framesReceived: number;
+    framesDroppedPercentage: number;
+    frameHeight: number;
+    frameWidth: number;
+    frameHeightStart: number;
+    frameWidthStart: number;
+    currentRoundTripTime: number;
+    packetsLostPerc: number;
+}
+export default class PeerConnection extends EventBase<WEBRTC_EVENT_TYPE, WebRTCEvent> {
+    private config;
+    private pc;
+    private dataChannel;
+    private offerOptions;
+    private pcConfig;
+    private netTestTimeout;
+    private aggregatedStats;
+    private lastThrowBadNetork;
+    private lastPacktetsLost;
+    private lastPacktetsReceived;
+    private larksr;
+    constructor(larksr: LarkSR, config: WebRTCConfig);
+    create(): void;
+    createOffer(): void;
+    close(): void;
+    onRemoteDescription(des: RTCSessionDescriptionInit): void;
+    onReceiveCandidate(candateInit: RTCIceCandidateInit | null): void;
+    startNetTest(): void;
+    stopNetTest(): void;
+    sendInput(input: Input.CloudLark.ClientInput): void;
+    sendBuffer(buffer: ArrayBuffer): void;
+    sendToAppTextMsg(msg: string): void;
+    sendToAppBinaryMsg(binary: Uint8Array): void;
+    changeOperater(uid: number): void;
+    inputText(txt: string): void;
+    private getStats;
+    private getStateChrome;
+    private onBadNetWork;
+    private onDataChannelMessage;
+    private onCreateOfferSuccess;
+    private onIceCandidate;
+    private onIceStateChange;
+    private gotRemoteStream;
+    private addIceCandidate;
+    private iceStateChange;
+    private $emit;
+    private createEvent;
+}
+export declare const K1 = "A829D283593455015A21E3509347AFD8";

package/dist/types/lark/sdp_util.d.ts

@@ -0,0 +1,36 @@
+export default class SdpUtil {
+    private static vp8;
+    private static vp9;
+    private static h264;
+    private static av1x;
+    private static h265;
+    private static hevc;
+    private static svac;
+    private static tail;
+    private static config;
+    static isLoopIpAddress(ip: string): boolean;
+    static getRtpmapRegByMode(mode: 'VP8' | 'VP9' | 'H264' | 'AV1X' | 'H265' | 'HEVC' | 'SVAC'): RegExp;
+    static hasVp8(sdp: string): boolean;
+    static hasVp9(sdp: string): boolean;
+    static hasH264(sdp: string): boolean;
+    static hasAV1X(sdp: string): boolean;
+    static hasH265(sdp: string): boolean;
+    static hasHEVC(sdp: string): boolean;
+    static hasSVAC(sdp: string): boolean;
+    static hasMode(sdp: string, mode: 'VP8' | 'VP9' | 'H264' | 'AV1X' | 'H265' | 'HEVC' | 'SVAC'): boolean;
+    static setAudioBitrate(sdp: string, bitrate: number): string;
+    static setBitRate(sdp: string, startBitrate: number, maxBitrate: number, minBitrate: number): string;
+    static setModeBitRate(sdp: string, startBitrate: number, maxBitrate: number, minBitrate: number, mode: 'VP8' | 'VP9' | 'H264' | 'AV1X'): string;
+    static removeVp8(sdp: string): string;
+    static removeVp9(sdp: string): string;
+    static removeH264(sdp: string): string;
+    static removeAV1X(sdp: string): string;
+    static removeH265(sdp: string): string;
+    static removeHEVC(sdp: string): string;
+    static removeSVAC(sdp: string): string;
+    static sdpFilter(sdp: string, mode: 'VP8' | 'VP9' | 'H264' | 'AV1X' | 'H265' | 'HEVC' | 'SVAC'): string;
+    static sdpGooAttrLine(...attrs: string[]): string;
+    static sdpBlankAttrLine(...attrs: string[]): string;
+    static getBlankAttrs(sdpLine: string): string[];
+    static getAttrName(sdpLine: string): string;
+}

package/dist/types/lark/websocket_channel.d.ts

@@ -0,0 +1,57 @@
+import { EventBase, LocalEvent } from '../event/event_base';
+import * as Msg from '../protobuf/cloudlark';
+import { LarkSR } from '../larksr';
+export declare enum CHANNEL_EVENT_TYPE {
+    OPEN = 0,
+    CLOSE = 1,
+    ERROR = 2,
+    CLIENT_MSG = 3
+}
+export interface ChannelEvent extends LocalEvent<CHANNEL_EVENT_TYPE> {
+    data?: Msg.CloudLark.ToClientMessage;
+}
+export interface WebscocketConfig {
+    serverAddress: string;
+    ip: string;
+    port: string;
+    path?: string;
+}
+export default class WebsocketChannel extends EventBase<CHANNEL_EVENT_TYPE, ChannelEvent> {
+    private get wsServer();
+    private config;
+    private connection;
+    private keepAliveTimeout;
+    private timerWorker;
+    private larksr;
+    constructor(config: WebscocketConfig, larksr: LarkSR);
+    /**
+     *
+     */
+    connect(): Promise<this>;
+    /**
+     *
+     */
+    close(): Promise<void>;
+    sendMsg(msg: Msg.CloudLark.ToServerMessage): void;
+    sendBuffer(data: ArrayBuffer): void;
+    isOpen(): boolean;
+    private startKeepAlive;
+    private stopKeepAlive;
+    /**
+     *
+     */
+    private onMessage;
+    private onOpen;
+    /**
+     *
+     * @param e
+     */
+    private onWSError;
+    /**
+     *
+     * @param e
+     */
+    private onWSClose;
+    private $emit;
+    private createEvent;
+}

package/dist/types/lark/websocket_proxy.d.ts

@@ -0,0 +1,57 @@
+import { EventBase, LocalEvent } from '../event/event_base';
+import * as Msg from '../protobuf/cloudlark';
+import { LarkSR } from '../larksr';
+export declare enum PROXY_EVENT_TYPE {
+    OPEN = 0,
+    CLOSE = 1,
+    ERROR = 2,
+    CLIENT_MSG = 3
+}
+export interface ProxyEvent extends LocalEvent<PROXY_EVENT_TYPE> {
+    data?: Msg.CloudLark.ToClientMessage;
+}
+export interface ProxyConfig {
+    serverAddress: string;
+    appServer: string;
+    appPort: string;
+}
+export declare const PROXY_PATH = "websocket";
+export default class WebsocketProxy extends EventBase<PROXY_EVENT_TYPE, ProxyEvent> {
+    private get wsServer();
+    private config;
+    private connection;
+    private keepAliveTimeout;
+    private timerWorker;
+    private larksr;
+    constructor(config: ProxyConfig, larksr: LarkSR);
+    /**
+     *
+     */
+    connect(): Promise<this>;
+    /**
+     *
+     */
+    close(): Promise<void>;
+    isOpen(): boolean;
+    sendMsg(msg: Msg.CloudLark.ToServerMessage): void;
+    sendBuffer(data: ArrayBuffer): void;
+    private startKeepAlive;
+    private stopKeepAlive;
+    /**
+     *
+     */
+    private onMessage;
+    private onOpen;
+    /**
+     *
+     * @param e
+     */
+    private onWSError;
+    /**
+     *
+     * @param e
+     */
+    private onWSClose;
+    private $emit;
+    private createEvent;
+}

package/dist/types/larksr.d.ts

@@ -0,0 +1,138 @@
+import { EventBase, LocalEvent } from './event/event_base';
+import Application, { APP_STATE } from './lark/application';
+import { AppliParams, AppliParamsUtils, IAppliParams, LoadAppliParamsStartAppInfo } from './appli_params';
+import { LarkEventType } from './lark/lark_event_type';
+import API from './api';
+import ScreenState from './screen_state';
+import Operation from './operation/operation';
+import { CloudLark } from './protobuf/cloudlark';
+import { KEYMAP } from './operation/keymap';
+import FullScreen from './utils/full_screen';
+import LockPointer from './utils/lock_pointer';
+import ScaleMode from './utils/scale_mode';
+import Capabilities from './utils/capabilities';
+declare const enum PlayerModeType {
+    Normal = 0,
+    Interactive = 1,
+    MutiPlayer = 2
+}
+declare const enum UserType {
+    Observer = 0,
+    Player = 1
+}
+interface LarkSREvent extends LocalEvent<LarkEventType> {
+    data?: any;
+    message: string;
+}
+interface ILarkSRConfig {
+    rootElement: HTMLElement;
+    serverAddress: string;
+    authCode?: string;
+    authCodeCallback?: (isSuccess: boolean, e: any) => void;
+    isMonitor?: boolean;
+    codeRate?: number;
+    frameRate?: number;
+    audioCodeRate?: number;
+    logLevel?: 'info' | 'warn' | 'error';
+    loadingTimeout?: number;
+    syncLocalToCloudClipboard?: boolean;
+    perferDecoder?: 'auto' | 'vp8' | 'vp9' | 'h264' | 'av1x';
+    scaleMode?: ScaleMode;
+    /**
+     * 全屏模式
+     *  0 -》 用户手动触发
+     *  1 -》 首次点击进入触发
+     *  2 -》 每次点击触发
+     */
+    fullScreenMode?: number;
+    mobileFullScreenMode?: number;
+    mobileForceLandscape?: boolean;
+}
+declare class LarkSR extends EventBase<LarkEventType, LarkSREvent> {
+    static EnterAppli(config: ILarkSRConfig, params: {
+        appliId: string;
+        playerMode?: number;
+        userType?: number;
+        roomCode?: string;
+        taskId?: string;
+    }): Promise<LarkSR>;
+    get params(): IAppliParams;
+    private _params;
+    get playerModeType(): PlayerModeType;
+    get userType(): UserType;
+    get isObMode(): boolean;
+    get isInteractiveMode(): boolean;
+    get appState(): APP_STATE;
+    get app(): Application;
+    private _app;
+    get remoteScreenReady(): boolean;
+    set remoteScreenReady(ready: boolean);
+    private _remoteScreenReady;
+    get screenState(): ScreenState;
+    private _screenState;
+    get op(): Operation;
+    private _op;
+    private iframeHandler;
+    get fullScreen(): FullScreen;
+    private _fullScreen;
+    get lockPointer(): LockPointer;
+    private _lockPointer;
+    private view;
+    get rootElement(): HTMLElement;
+    private _rootElement;
+    get serverAddress(): string;
+    private _serverAddress;
+    get serverIp(): string;
+    get config(): ILarkSRConfig;
+    private _config;
+    private loadingTimeout;
+    private sdkAuth;
+    constructor(config: ILarkSRConfig, params: IAppliParams);
+    initSDKAuthCode(id: string): Promise<void>;
+    start(): Promise<void>;
+    restart(): void;
+    restartApp(): void;
+    changeOperater(uid: number): void;
+    inputText(text: string): void;
+    sendTextToDataChannel(text: string): void;
+    sendBinaryToDataChannel(binary: Uint8Array): void;
+    postMsg(type: LarkEventType, data?: any, msg?: string): void;
+    /**
+     *  退出当前页面
+     */
+    quit(): void;
+    sendInput(input: CloudLark.IClientInput): void;
+    moseMove(PosX: number, PosY: number, DeltaX: number, DeltaY: number): void;
+    mouseTap(PosX: number, PosY: number, key: CloudLark.MouseKey): void;
+    mouseDown(PosX: number, PosY: number, key: CloudLark.MouseKey): void;
+    mouseUp(PosX: number, PosY: number, key: CloudLark.MouseKey): void;
+    mouseWheel(PosX: number, PosY: number, Delata: number): void;
+    keyDown(key: string, isRepeat: boolean): void;
+    keyUp(key: string): void;
+    gamepadButtonDown(userIndex: number, button: number, isRepeat: boolean): void;
+    gamepadButtonUp(userIndex: number, button: number): void;
+    gamepadTrigger(userIndex: number, isleft: boolean, value: number): void;
+    joystick(userIndex: number, thumblx: number, thumbly: number, thumbrx: number, thumbry: number): void;
+    touchDown(id: number, x: number, y: number): void;
+    touchMove(id: number, x: number, y: number): void;
+    touchUp(id: number, x: number, y: number): void;
+    getMouseButtonType(button: 'left' | 'mid' | 'right'): CloudLark.MouseKey;
+    $emit(type: LarkEventType, data?: any, message?: string): void;
+    private createEvent;
+    private taskProcess;
+    private startProcess;
+    private onAppStateChange;
+    private onGotRemoteStream;
+    private onCursorStyle;
+    private onAppResize;
+    private onAppMouseMode;
+    private onAppPlayerList;
+    private onAppRequestText;
+    private onDataChannelText;
+    private onDataChannelBinary;
+    private onDataChannelOpen;
+    private onDataChannelClose;
+    private onOperationTimeout;
+    private onOperationInput;
+}
+export { LarkSR, ILarkSRConfig, PlayerModeType, UserType, LarkSREvent, AppliParams, AppliParamsUtils, LoadAppliParamsStartAppInfo, EventBase, LocalEvent, API, Operation, Capabilities, ScaleMode, KEYMAP, CloudLark, FullScreen, LockPointer, };

package/dist/types/localization/base.d.ts

@@ -0,0 +1,8 @@
+export default class LocalizationBase {
+    protected mType: string;
+    protected mData: any;
+    protected mLoaded: boolean;
+    get type(): string;
+    get data(): any;
+    loadData(data: any): void;
+}

package/dist/types/localization/gesture_ins.d.ts

@@ -0,0 +1,4 @@
+import LocalizationBase from './base';
+export default class GestureIns extends LocalizationBase {
+    protected mType: string;
+}

package/dist/types/localization/language.d.ts

@@ -0,0 +1,6 @@
+export declare enum SupportLanguage {
+    CN = 0,
+    EN = 1
+}
+export declare function isChinese(codeString: string): boolean;
+export declare function getSupportLanguageFromCodeStr(codeString: string): SupportLanguage;

package/dist/types/localization/loader.d.ts

@@ -0,0 +1,14 @@
+import Message from './message';
+import GestureIns from './gesture_ins';
+import UI from './ui';
+export default class LocalizationLoader {
+    private static mLanguageCode;
+    private static mMessage;
+    private static mGestureIns;
+    private static mUI;
+    static getPrePath(): string;
+    static init(code: string): void;
+    static get message(): Message;
+    static get gestureIns(): GestureIns;
+    static get ui(): UI;
+}