larksr_websdk 3.2.340 → 3.2.341

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

@@ -0,0 +1,191 @@
+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';
+import PixelStreamingWebsocketChannel from './test_pixel_streaming';
+import { RECORDER_STATE } from './recoder';
+export declare enum APP_STATE {
+    BEFORE_CREATE = 0,
+    INITED = 1,
+    WEBSOCKET_CHANNEL_OPEN = 2,
+    LOGIN_SUCCESS = 3,
+    RTC_CONNECTED = 4,
+    MEDIA_LOADED = 5,
+    MEDIA_PLAYED = 6,
+    RTC_RETRY = 7,
+    APP_RETRY = 8,
+    BEFORE_DESTORY = 9,
+    WEBSOCKET_CLOSED = 10,
+    RTC_CLOSED = 11,
+    DESTROYED = 12
+}
+export declare enum APP_EVENT_TYPE {
+    CONNECT = 0,
+    LOGIN = 1,
+    ERROR = 2,
+    INFO = 3,
+    APP_CLOSE = 4,
+    REMOTE_STREAM = 5,
+    REMOTE_AUDIO_STREAM = 6,
+    SYNC_CURSORSTYLE = 7,
+    APP_STATE_CHANGE = 8,
+    NET_STATE = 9,
+    LK_APP_RESIZE = 10,
+    LK_APP_MOUSE_MODE = 11,
+    LK_APP_PLAER_LIST = 12,
+    LK_APP_REQUEST_TEXT = 13,
+    LK_DATA_CHANNEL_RENDERSERVER_TEXT_MESSAGE = 14,
+    LK_DATA_CHANNEL_RENDERSERVER_BINARY_MESSAGE = 15,
+    LK_DATA_CHANNEL_RENDERSERVER_OPEN = 16,
+    LK_DATA_CHANNEL_RENDERSERVER_CLOSE = 17,
+    AI_VOICE_STATUS = 18,
+    AI_VOICE_ASR_RESULT = 19,
+    AI_VOICE_DM_RESULT = 20,
+    AI_VOICE_ERROR = 21,
+    RTMP_STREAM_STATE = 22,
+    RTMP_STREAM_ERROR = 23,
+    RTC_RETRY_SUCCESS = 24
+}
+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 testPixelStreaming;
+    private peerConnection;
+    private mediaSharePeerConnectionImp;
+    get peerConnectionCreated(): boolean;
+    get state(): APP_STATE;
+    set state(state: APP_STATE);
+    private _state;
+    get audioDeviceId(): string | null | undefined;
+    get audioTrack(): MediaStreamTrack | null | undefined;
+    get videoDeviceId(): string | null | undefined;
+    get videoTrack(): MediaStreamTrack | null | undefined;
+    get audioPaused(): boolean | undefined;
+    get videoPaused(): boolean | undefined;
+    get serverFeatures(): Msg.CloudLark.INotifyFeatures | null | undefined;
+    private get sharePeerConnection();
+    private retryTime;
+    private larksr;
+    get voiceId(): number;
+    get recodeState(): RECORDER_STATE;
+    private recoder;
+    private rtcConfig;
+    constructor(larksr: LarkSR);
+    init(): void;
+    initSharePc(): void;
+    initPc(): void;
+    releasePc(): void;
+    releaseSharePc(): void;
+    closeSharePc(): void;
+    clear(): void;
+    changeOperater(uid: number): void;
+    inputText(text: string): void;
+    sendTextToDataChannel(text: string): void;
+    sendBinaryToDataChannel(binary: Uint8Array): void;
+    aiDmTextInput(text: string): number;
+    startAiDmVoiceInput(): Promise<number>;
+    stopAiDmVoiceInput(): number;
+    private onRecoderData;
+    start(): Promise<void>;
+    connect(): Promise<PixelStreamingWebsocketChannel> | Promise<WebsocketProxy> | Promise<WebSocektChannel> | undefined;
+    disConnect(): void;
+    closeRtc(): void;
+    versionCheck(): void;
+    task(): void;
+    startSteam(): void;
+    startMonitorSteam(): void;
+    restart(): void;
+    restartApp(): void;
+    rtcOffer(): Promise<void>;
+    setAnswer(sdp: string): void;
+    setIce(sdpMlineindex: number, sdpmid: string, candidate: string): void;
+    sendInput(input: Msg.CloudLark.ClientInput): void;
+    sendInputBuffer(buffer: ArrayBuffer): void;
+    private sendToWebsocektChannelBuffer;
+    private sendToWebsocektChannelMsg;
+    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 onAudioRemoteStream;
+    private onRtcError;
+    private onRtcInfo;
+    private onRtmpStreamingState;
+    private onRtmpStreamingError;
+    private onIceStateChange;
+    retryPeerconnection(): void;
+    private onShareMediaError;
+    private onShareMediaInfo;
+    private onShareMediaOffer;
+    private onShareMediaIce;
+    setAudioEnable(enable: boolean): any;
+    setVideoEnable(enable: boolean): any;
+    setShareEnable(enable: boolean): any;
+    stopLocalAudio(): any;
+    stopLocalVideo(): any;
+    stopLocalShare(): any;
+    pauseAudioSending(): any;
+    resumeAudioSending(): any;
+    pauseVideoSending(): any;
+    resumeVideoSending(): any;
+    closeAudio(): any;
+    closeVideo(): any;
+    closeShare(): any;
+    openAudio(deviceId?: string): Promise<any>;
+    openVideo(audio?: boolean, cameraId?: string, width?: number, height?: number, front?: boolean): Promise<any>;
+    openDefaultMedia(video?: boolean, audio?: boolean): Promise<any>;
+    openShareMediaDevice(): Promise<any>;
+    getConnectedAudioinputDevices(): Promise<any>;
+    getConnectedAudioOutputDevices(): Promise<any>;
+    getConnectedVideoinputDevices(): Promise<any>;
+    getConnectedDevices(type: MediaDeviceKind): Promise<any>;
+    openAudioDevice(deviceId: string, kind?: "audioinput" | "audiooutput"): Promise<any>;
+    openCamera(cameraId: string, minWidth?: number, minHeight?: number, audio?: boolean, front?: boolean): Promise<any>;
+    openUserMeida(constraints?: MediaStreamConstraints, reset?: boolean): Promise<any>;
+    addMediaTrack(track: MediaStreamTrack, ...streams: MediaStream[]): boolean | undefined;
+    removeMediaTrack(track: RTCRtpSender): any;
+    requestUserMediaPermission(constraints?: MediaStreamConstraints): any;
+    StartCloudLiveStreaming(params: Msg.CloudLark.IRtmp_Start): Promise<void> | undefined;
+    StopLiveStreaming(): void | undefined;
+    private onPeerConnectionDisconnect;
+    private onBadNetwork;
+    private onPixelStreamingPlayerList;
+    private onPixelStreamingDataChannelState;
+    private onPixelStreamingDataChannelData;
+    private onCursorStyle;
+    private onAppResize;
+    private onAppMouseMode;
+    private onAppPlayerList;
+    private onAppRequestText;
+    private onDataChannelText;
+    private onDataChannelBinary;
+    private onDataChannelOpen;
+    private onDataChannelClose;
+    private onPeerConnectionState;
+    private onAiVoiceStatus;
+    private onAiVoiceAsrResult;
+    private onAiVoiceDMResult;
+    private onAiVoiceError;
+    appStateChange(state: APP_STATE): void;
+    private infoMsg;
+    private errorMsg;
+    private toastMsg;
+    private $emit;
+    private createAppEvent;
+}

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

@@ -0,0 +1,28 @@
+import ScreenState from '@/screen_state';
+export default class CanvasRender {
+    get canvas(): HTMLCanvasElement | null;
+    private set canvas(value);
+    private _canvas;
+    private context;
+    private width;
+    private height;
+    private video;
+    private drawFrames;
+    private stream;
+    private screenState;
+    private hasDeviceOrientationEvent;
+    private alpha;
+    private beta;
+    private gamma;
+    private isFront;
+    private currentRotateClock;
+    constructor(screenState: ScreenState);
+    init(stream: MediaStream): Promise<HTMLCanvasElement>;
+    draw(): void;
+    stopDrawing(): void;
+    clear(): void;
+    setRotate(clock: boolean): void;
+    clearRotate(): void;
+    setupRotateWithDeivce(): void;
+    private checkFront;
+}

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/ice_candiadate_parser.d.ts

@@ -0,0 +1,24 @@
+export default class IceCandidateParser {
+    sdpMLineIndex: number | null;
+    sdpMid: string | null;
+    usernameFragment: string | null;
+    header: string;
+    private props;
+    constructor(ice: RTCIceCandidateInit);
+    get foundation(): string;
+    set foundation(f: string);
+    get component(): string;
+    set component(f: string);
+    get protocol(): string;
+    set protocol(p: string);
+    get priority(): string;
+    set priority(p: string);
+    get ip(): string;
+    set ip(ip: string);
+    get port(): string;
+    set port(port: string);
+    get type(): string;
+    get candidate(): string;
+    genNewIceCandidateInit(): RTCIceCandidateInit;
+    genNewIceCandidate(): RTCIceCandidate;
+}

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

@@ -0,0 +1,114 @@
+export declare enum LarkEventType {
+    LK_WEB_CLIENT_LOAD_SUCCESS = 1,
+    LK_TASK_CREATE_SUCCESS = 10,
+    LK_TASK_CREATE_FAILED = 11,
+    LK_RESOURCE_NOT_ENOUGH = 12,
+    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_CREATE_FAILED = 603,
+    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_VIDEO_PLAY_SUCCSS = 711,
+    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_OPENAUDIO_INPUT = 10040,
+    LK_IFRAME_POSTER_CLOSE_AUDIO_INPUT = 10041,
+    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/media_share_interface.d.ts

@@ -0,0 +1,46 @@
+export interface RTCMediaTrackBinding {
+    deviceId: string;
+    track: MediaStreamTrack;
+    sender: RTCRtpSender | undefined;
+}
+export interface RTCShareMediaTrackBinding {
+    deviceId: string;
+    track: MediaStreamTrack;
+    transceiver: RTCRtpTransceiver | undefined;
+    paused: boolean;
+}
+export interface MediaShareInterface {
+    audioDeviceId: string | undefined | null;
+    audioTrack: MediaStreamTrack | undefined | null;
+    videoDeviceId: string | undefined | null;
+    videoTrack: MediaStreamTrack | undefined | null;
+    audioPaused: boolean;
+    videoPaused: boolean;
+    setAudioEnable(enable: boolean): any;
+    setVideoEnable(enable: boolean): any;
+    setShareEnable(enable: boolean): any;
+    stopLocalAudio(): any;
+    stopLocalVideo(): any;
+    stopLocalShare(): any;
+    pauseAudioSending(): any;
+    resumeAudioSending(): any;
+    pauseVideoSending(): any;
+    resumeVideoSending(): any;
+    closeAudio(): any;
+    closeVideo(): any;
+    closeShare(): any;
+    openAudio(deviceId: string): Promise<any>;
+    openVideo(audio: boolean, cameraId: string, width: number, height: number, front?: boolean): Promise<any>;
+    openDefaultMedia(video: boolean, audio: boolean): Promise<any>;
+    openShareMediaDevice(): Promise<any>;
+    getConnectedAudioinputDevices(): Promise<any>;
+    getConnectedAudioOutputDevices(): Promise<any>;
+    getConnectedVideoinputDevices(): Promise<any>;
+    getConnectedDevices(type: MediaDeviceKind): Promise<any>;
+    openAudioDevice(deviceId: string, kind: "audioinput" | "audiooutput"): Promise<any>;
+    openCamera(cameraId: string, minWidth: number, minHeight: number, audio: boolean, front?: boolean): Promise<any>;
+    openUserMeida(constraints?: MediaStreamConstraints, reset?: boolean): Promise<any>;
+    addMediaTrack(track: MediaStreamTrack, ...streams: MediaStream[]): boolean;
+    removeMediaTrack(track: RTCRtpSender): any;
+    requestUserMediaPermission(constraints?: MediaStreamConstraints): any;
+}

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

@@ -0,0 +1,22 @@
+import * as Msg from '../protobuf/cloudlark';
+import { LarkEventType } from './lark_event_type';
+export declare const MESSAGE_MAGIC = 538317090;
+export declare const PIXEL_STREAMING_MESSAGE_MAGIC = 539037986;
+export default class Message {
+    static emptyMsg(isPixelStreaming?: boolean): Msg.CloudLark.ToServerMessage;
+    static versionCheckRequest(isPixelStreaming: boolean): Msg.CloudLark.ToServerMessage;
+    static taskRequest(taskid: string, isInteractiveMode: boolean, isObMode: boolean, nickName: string, isPixelStreaming: boolean): Msg.CloudLark.ToServerMessage;
+    static startStreamReqeuest(request: Msg.CloudLark.IStartStreamRequest, isPixelStreaming: boolean): 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, username: string | null | undefined): Msg.CloudLark.ToServerMessage;
+    static mediaShareRtcOfferMsg(type: string, sdp: string): Msg.CloudLark.ToServerMessage;
+    static mediaShareIceMsg(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, reason?: string | null | undefined): string;
+    static getCloudlarkStartStreamingEventMsg(type: LarkEventType): string;
+}

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

@@ -0,0 +1,191 @@
+import { EventBase, LocalEvent } from '../event/event_base';
+import * as Input from '../protobuf/cloudlark';
+import { LarkSR } from '../larksr';
+import { MediaShareInterface, RTCMediaTrackBinding } from './media_share_interface';
+import { CloudLark } from '@/protobuf/cloudlark';
+export declare enum IceState {
+    DISCONNECT = 1,
+    BAD = 2,
+    CONNECT = 3,
+    GOOD = 4
+}
+export declare enum WEBRTC_EVENT_TYPE {
+    GOT_REMOTE_STREAM = 0,
+    GOT_REMOTE_AUDIO_STREAM = 1,
+    ICE_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,
+    LK_RTC_EVENT_PEERCONNECTION_STATE = 11,
+    NET_STATE = 12,
+    SYNC_CURSORSTYLE = 13,
+    BAD_NETWORK = 14,
+    ERROR = 15,
+    RTC_SDP = 16,
+    RTC_ICECANDIDATE = 17,
+    AI_VOICE_STATUS = 18,
+    AI_VOICE_ASR_RESULT = 19,
+    AI_VOICE_DM_RESULT = 20,
+    AI_VOICE_ERROR = 21,
+    RTMP_STREAM_STATE = 22,
+    RTMP_STREAM_ERROR = 23,
+    INFO = 24
+}
+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> implements MediaShareInterface {
+    private config;
+    private pc;
+    private dataChannel;
+    private offerOptions;
+    private pcConfig;
+    private netTestTimeout;
+    private aggregatedStats;
+    private lastThrowBadNetork;
+    private lastPacktetsLost;
+    private lastPacktetsReceived;
+    private larksr;
+    private audioStream;
+    private videoStream;
+    get audioDeviceId(): string | undefined;
+    get audioTrack(): MediaStreamTrack | undefined;
+    get videoDeviceId(): string | undefined;
+    get videoTrack(): MediaStreamTrack | undefined;
+    get audioPaused(): boolean;
+    get videoPaused(): boolean;
+    private audioBinding;
+    private videoBinding;
+    private readonly sendStream;
+    private sdpCreateSuccess;
+    private canvasRender;
+    get serverFeatures(): CloudLark.INotifyFeatures | null;
+    private _serverFeatures;
+    constructor(larksr: LarkSR, config: WebRTCConfig);
+    create(streams?: MediaStream | undefined | null, config?: CloudLark.IRTCConfiguration | null | undefined): Promise<void>;
+    createOffer(): void;
+    close(): void;
+    setAudioEnable(enable: boolean): void;
+    setVideoEnable(enable: boolean): void;
+    setShareEnable(enable: boolean): void;
+    stopLocalAudio(): void;
+    stopLocalVideo(): void;
+    stopLocalShare(): void;
+    pauseAudioSending(): false | undefined;
+    resumeAudioSending(): false | undefined;
+    pauseVideoSending(): false | undefined;
+    resumeVideoSending(): false | undefined;
+    closeAudio(): false | undefined;
+    closeVideo(): false | undefined;
+    closeShare(): false | undefined;
+    private stopLocalTrackBing;
+    openAudio(deviceId?: string): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    openVideo(audio?: boolean, cameraId?: string, width?: number, height?: number, front?: boolean): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    openDefaultMedia(video?: boolean, audio?: boolean): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    openShareMediaDevice(): Promise<void>;
+    getConnectedAudioinputDevices(): Promise<MediaDeviceInfo[]>;
+    getConnectedAudioOutputDevices(): Promise<MediaDeviceInfo[]>;
+    getConnectedVideoinputDevices(): Promise<MediaDeviceInfo[]>;
+    getConnectedDevices(type: MediaDeviceKind): Promise<MediaDeviceInfo[]>;
+    openAudioDevice(deviceId: string, kind?: "audioinput" | "audiooutput"): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    openCamera(cameraId: string, width?: number, height?: number, audio?: boolean, front?: boolean): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    openUserMeida(constraints?: MediaStreamConstraints, reset?: boolean): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    private resumeOrCreateBinding;
+    addMediaTrack(track: MediaStreamTrack, ...streams: MediaStream[]): boolean;
+    removeMediaTrack(track: RTCRtpSender): boolean;
+    requestUserMediaPermission(constraints?: MediaStreamConstraints): Promise<MediaStream>;
+    /**
+     * 接收到sdp
+     * @param des sdp
+     */
+    onRemoteDescription(des: RTCSessionDescriptionInit): void;
+    onReceiveCandidate(candateInit: RTCIceCandidateInit): void;
+    startNetTest(): void;
+    stopNetTest(): void;
+    sendInput(input: Input.CloudLark.ClientInput): void;
+    sendBuffer(buffer: ArrayBuffer): void;
+    sendToAppTextMsg(msg: string): void;
+    sendToAppBinaryMsg(binary: Uint8Array): void;
+    StartCloudLiveStreaming(params: Input.CloudLark.IRtmp_Start): Promise<void>;
+    StopLiveStreaming(): void;
+    changeOperater(uid: number): void;
+    inputText(txt: string): void;
+    private getStats;
+    private getStateChrome;
+    private onBadNetWork;
+    private onDataChannelMessage;
+    private onCreateOfferSuccess;
+    private onIceCandidate;
+    private onIceStateChange;
+    private ontrack;
+    private addIceCandidate;
+    private iceStateChange;
+    private $emit;
+    private createEvent;
+}