ring-client-api 10.0.0-beta.5 → 10.0.0-beta.8

package/lib/api/streaming/streaming-connection-base.js

@@ -0,0 +1,111 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingConnectionBase = void 0;
+const peer_connection_1 = require("./peer-connection");
+const subscribed_1 = require("../subscribed");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const util_1 = require("../util");
+class StreamingConnectionBase extends subscribed_1.Subscribed {
+    constructor(ws, options = {}) {
+        super();
+        this.ws = ws;
+        this.options = options;
+        this.onCallAnswered = new rxjs_1.ReplaySubject(1);
+        this.onCallEnded = new rxjs_1.ReplaySubject(1);
+        this.activated = false;
+        if (options.createPeerConnection) {
+            // we were passed a custom peer connection factory
+            this.pc = options.createPeerConnection();
+            // passing rtp packets is not supported for custom peer connections
+            this.onAudioRtp = new rxjs_1.Subject();
+            this.onVideoRtp = new rxjs_1.Subject();
+        }
+        else {
+            // no custom peer connection factory, use the werift and pass along rtp packets
+            const pc = new peer_connection_1.WeriftPeerConnection();
+            this.pc = pc;
+            this.onAudioRtp = pc.onAudioRtp;
+            this.onVideoRtp = pc.onVideoRtp;
+        }
+        this.onWsOpen = (0, rxjs_1.fromEvent)(this.ws, 'open');
+        const onMessage = (0, rxjs_1.fromEvent)(this.ws, 'message'), onError = (0, rxjs_1.fromEvent)(this.ws, 'error'), onClose = (0, rxjs_1.fromEvent)(this.ws, 'close');
+        this.addSubscriptions(onMessage
+            .pipe((0, operators_1.concatMap)((message) => {
+            return this.handleMessage(JSON.parse(message.data));
+        }))
+            .subscribe(), onError.subscribe((e) => {
+            (0, util_1.logError)(e);
+            this.callEnded();
+        }), onClose.subscribe(() => {
+            this.callEnded();
+        }), this.pc.onConnectionState.subscribe((state) => {
+            if (state === 'failed') {
+                (0, util_1.logError)('Stream connection failed');
+                this.callEnded();
+            }
+            if (state === 'closed') {
+                (0, util_1.logDebug)('Stream connection closed');
+                this.callEnded();
+            }
+        }));
+    }
+    activate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.activated) {
+                return;
+            }
+            this.activated = true;
+            yield (0, rxjs_1.firstValueFrom)(this.pc.onConnectionState.pipe((0, operators_1.filter)((state) => state === 'connected')));
+            (0, util_1.logInfo)('Activating Session');
+            this.sendSessionMessage('activate_session');
+        });
+    }
+    activateCameraSpeaker() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
+            this.sendSessionMessage('camera_options', {
+                stealth_mode: false,
+            });
+        });
+    }
+    sendMessage(message) {
+        this.ws.send(JSON.stringify(message));
+    }
+    sendAudioPacket(rtp) {
+        if (this.pc instanceof peer_connection_1.WeriftPeerConnection) {
+            this.pc.returnAudioTrack.writeRtp(rtp);
+        }
+        else {
+            throw new Error('Cannot send audio packets to a custom peer connection implementation');
+        }
+    }
+    callEnded() {
+        try {
+            this.sendMessage({
+                reason: { code: 0, text: '' },
+                method: 'close',
+            });
+            this.ws.close();
+        }
+        catch (_) {
+            // ignore any errors since we are stopping the call
+        }
+        this.unsubscribe();
+        this.onCallEnded.next();
+        this.pc.close();
+    }
+    stop() {
+        this.callEnded();
+    }
+}
+exports.StreamingConnectionBase = StreamingConnectionBase;

package/lib/api/{live-call.d.ts → streaming/streaming-session.d.ts}

@@ -1,7 +1,9 @@
-import { ReplaySubject } from 'rxjs';
-import { RingCamera } from './ring-camera';
-import { Subscribed } from './subscribed';
 import { RtpPacket } from '@koush/werift';
+import { ReplaySubject, Subject } from 'rxjs';
+import { RingEdgeConnection } from './ring-edge-connection';
+import { WebrtcConnection } from './webrtc-connection';
+import { RingCamera } from '../ring-camera';
+import { Subscribed } from '../subscribed';
 declare type SpawnInput = string | number;
 export interface FfmpegOptions {
     input?: SpawnInput[];
@@ -9,27 +11,22 @@ export interface FfmpegOptions {
     audio?: SpawnInput[];
     output: SpawnInput[];
 }
-export declare class LiveCall extends Subscribed {
-    private sessionId;
-    private camera;
-    private readonly ws;
-    private readonly onWsOpen;
-    private readonly onMessage;
-    private readonly pc;
-    readonly onCallAnswered: ReplaySubject<string>;
+export declare class StreamingSession extends Subscribed {
+    private readonly camera;
+    private connection;
     readonly onCallEnded: ReplaySubject<void>;
+    readonly onVideoRtp: Subject<RtpPacket>;
+    readonly onAudioRtp: Subject<RtpPacket>;
     private readonly audioSplitter;
     private readonly videoSplitter;
-    readonly onVideoRtp: import("rxjs").Subject<RtpPacket>;
-    readonly onAudioRtp: import("rxjs").Subject<RtpPacket>;
-    constructor(sessionId: string, camera: RingCamera);
-    private handleMessage;
-    reservePort(bufferPorts?: number): Promise<number>;
-    startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
+    constructor(camera: RingCamera, connection: RingEdgeConnection | WebrtcConnection);
+    private bindToConnection;
     activated: boolean;
     activate(): Promise<void>;
+    cameraSpeakerActivated: boolean;
     activateCameraSpeaker(): Promise<void>;
-    private sendMessage;
+    reservePort(bufferPorts?: number): Promise<number>;
+    startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
     private callEnded;
     stop(): void;
     sendAudioPacket(rtp: RtpPacket): void;

package/lib/api/{live-call.js → streaming/streaming-session.js}

@@ -9,15 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiveCall = void 0;
-const ws_1 = require("ws");
+exports.StreamingSession = void 0;
+const camera_utils_1 = require("@homebridge/camera-utils");
 const rxjs_1 = require("rxjs");
-const peer_connection_1 = require("./peer-connection");
-const util_1 = require("./util");
+const ffmpeg_1 = require("../ffmpeg");
+const util_1 = require("../util");
 const operators_1 = require("rxjs/operators");
-const subscribed_1 = require("./subscribed");
-const camera_utils_1 = require("@homebridge/camera-utils");
-const ffmpeg_1 = require("./ffmpeg");
+const subscribed_1 = require("../subscribed");
 function getCleanSdp(sdp, includeVideo) {
     return sdp
         .split('\nm=')
@@ -26,62 +24,39 @@ function getCleanSdp(sdp, includeVideo) {
         .filter((section) => includeVideo || !section.startsWith('m=video'))
         .join('\n');
 }
-function parseLiveCallSession(sessionId) {
-    const encodedSession = sessionId.split('.')[1], buff = Buffer.from(encodedSession, 'base64'), text = buff.toString('ascii');
-    return JSON.parse(text);
-}
-class LiveCall extends subscribed_1.Subscribed {
-    constructor(sessionId, camera) {
+class StreamingSession extends subscribed_1.Subscribed {
+    constructor(camera, connection) {
         super();
-        this.sessionId = sessionId;
         this.camera = camera;
-        this.onCallAnswered = new rxjs_1.ReplaySubject(1);
+        this.connection = connection;
         this.onCallEnded = new rxjs_1.ReplaySubject(1);
+        this.onVideoRtp = new rxjs_1.Subject();
+        this.onAudioRtp = new rxjs_1.Subject();
         this.audioSplitter = new camera_utils_1.RtpSplitter();
         this.videoSplitter = new camera_utils_1.RtpSplitter();
         this.activated = false;
-        const liveCallSession = parseLiveCallSession(sessionId);
-        this.pc = new peer_connection_1.PeerConnection();
-        this.ws = new ws_1.WebSocket(`wss://${liveCallSession.rms_fqdn}:${liveCallSession.webrtc_port}/`, {
-            headers: {
-                API_VERSION: '3.1',
-                API_TOKEN: sessionId,
-                CLIENT_INFO: 'Ring/3.49.0;Platform/Android;OS/7.0;Density/2.0;Device/samsung-SM-T710;Locale/en-US;TimeZone/GMT-07:00',
-            },
+        this.cameraSpeakerActivated = false;
+        this.bindToConnection(connection);
+    }
+    bindToConnection(connection) {
+        this.addSubscriptions(connection.onAudioRtp.subscribe(this.onAudioRtp), connection.onVideoRtp.subscribe(this.onVideoRtp));
+    }
+    activate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.activated) {
+                return;
+            }
+            this.activated = true;
+            yield this.connection.activate();
         });
-        this.onAudioRtp = this.pc.onAudioRtp;
-        this.onVideoRtp = this.pc.onVideoRtp;
-        this.onMessage = (0, rxjs_1.fromEvent)(this.ws, 'message');
-        this.onWsOpen = (0, rxjs_1.fromEvent)(this.ws, 'open');
-        const onError = (0, rxjs_1.fromEvent)(this.ws, 'error'), onClose = (0, rxjs_1.fromEvent)(this.ws, 'close');
-        this.addSubscriptions(this.onMessage
-            .pipe((0, operators_1.concatMap)((message) => {
-            return this.handleMessage(JSON.parse(message.data));
-        }))
-            .subscribe(), this.onWsOpen.subscribe(() => {
-            (0, util_1.logDebug)(`WebSocket connected for ${this.camera.name}`);
-        }), onError.subscribe((e) => {
-            (0, util_1.logError)(e);
-            this.callEnded();
-        }), onClose.subscribe(() => {
-            this.callEnded();
-        }));
     }
-    handleMessage(message) {
+    activateCameraSpeaker() {
         return __awaiter(this, void 0, void 0, function* () {
-            switch (message.method) {
-                case 'sdp':
-                    const answer = yield this.pc.createAnswer(message);
-                    this.sendMessage(Object.assign({ method: 'sdp' }, answer));
-                    this.onCallAnswered.next(message.sdp);
-                    return;
-                case 'ice':
-                    yield this.pc.addIceCandidate({
-                        candidate: message.ice,
-                        sdpMLineIndex: message.mlineindex,
-                    });
-                    return;
+            if (this.cameraSpeakerActivated) {
+                return;
             }
+            this.cameraSpeakerActivated = true;
+            yield this.connection.activateCameraSpeaker();
         });
     }
     reservePort(bufferPorts = 0) {
@@ -103,7 +78,7 @@ class LiveCall extends subscribed_1.Subscribed {
                 ...(ffmpegOptions.input || []),
                 '-i',
                 'pipe:',
-            ], ringSdp = yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered), inputSdp = getCleanSdp(ringSdp, transcodeVideoStream)
+            ], ringSdp = yield (0, rxjs_1.firstValueFrom)(this.connection.onCallAnswered), inputSdp = getCleanSdp(ringSdp, transcodeVideoStream)
                 .replace(/m=audio \d+/, `m=audio ${audioPort}`)
                 .replace(/m=video \d+/, `m=video ${videoPort}`), ff = new camera_utils_1.FfmpegProcess({
                 ffmpegArgs: ffmpegInputArguments.concat(...(ffmpegOptions.audio || ['-acodec', 'aac']), ...(transcodeVideoStream
@@ -139,48 +114,10 @@ class LiveCall extends subscribed_1.Subscribed {
             yield this.activate();
         });
     }
-    activate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.activated) {
-                return;
-            }
-            this.activated = true;
-            yield (0, rxjs_1.firstValueFrom)(this.pc.onConnectionState.pipe((0, operators_1.filter)((state) => state === 'connected')));
-            (0, util_1.logInfo)('Activating Session');
-            this.sendMessage({ method: 'activate_session' });
-            this.sendMessage({
-                video_enabled: true,
-                audio_enabled: true,
-                method: 'stream_options',
-            });
-        });
-    }
-    activateCameraSpeaker() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
-            this.sendMessage({
-                stealth_mode: false,
-                method: 'camera_options',
-            });
-        });
-    }
-    sendMessage(message) {
-        this.ws.send(JSON.stringify(message));
-    }
     callEnded() {
-        try {
-            this.sendMessage({
-                reason: { code: 0, text: '' },
-                method: 'close',
-            });
-            this.ws.close();
-        }
-        catch (_) {
-            // ignore any errors since we are stopping the call
-        }
         this.unsubscribe();
         this.onCallEnded.next();
-        this.pc.close();
+        this.connection.stop();
         this.audioSplitter.close();
         this.videoSplitter.close();
     }
@@ -188,7 +125,7 @@ class LiveCall extends subscribed_1.Subscribed {
         this.callEnded();
     }
     sendAudioPacket(rtp) {
-        this.pc.returnAudioTrack.writeRtp(rtp);
+        this.connection.sendAudioPacket(rtp);
     }
 }
-exports.LiveCall = LiveCall;
+exports.StreamingSession = StreamingSession;

package/lib/api/streaming/webrtc-connection.d.ts

@@ -0,0 +1,23 @@
+import { RingCamera } from '../ring-camera';
+import { StreamingConnectionBase, StreamingConnectionOptions } from './streaming-connection-base';
+interface InitializationMessage {
+    method: 'initialization';
+    text: 'Done';
+}
+interface OfferMessage {
+    method: 'sdp';
+    sdp: string;
+    type: 'offer';
+}
+interface IceCandidateMessage {
+    method: 'ice';
+    ice: string;
+    mlineindex: number;
+}
+export declare class WebrtcConnection extends StreamingConnectionBase {
+    private sessionId;
+    constructor(sessionId: string, camera: RingCamera, options: StreamingConnectionOptions);
+    protected handleMessage(message: InitializationMessage | OfferMessage | IceCandidateMessage): Promise<void>;
+    protected sendSessionMessage(method: string, body?: Record<any, any>): void;
+}
+export {};

package/lib/api/streaming/webrtc-connection.js

@@ -0,0 +1,60 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebrtcConnection = void 0;
+const ws_1 = require("ws");
+const streaming_connection_base_1 = require("./streaming-connection-base");
+const util_1 = require("../util");
+function parseLiveCallSession(sessionId) {
+    const encodedSession = sessionId.split('.')[1], buff = Buffer.from(encodedSession, 'base64'), text = buff.toString('ascii');
+    return JSON.parse(text);
+}
+class WebrtcConnection extends streaming_connection_base_1.StreamingConnectionBase {
+    constructor(sessionId, camera, options) {
+        const liveCallSession = parseLiveCallSession(sessionId);
+        super(new ws_1.WebSocket(`wss://${liveCallSession.rms_fqdn}:${liveCallSession.webrtc_port}/`, {
+            headers: {
+                API_VERSION: '3.1',
+                API_TOKEN: sessionId,
+                CLIENT_INFO: 'Ring/3.49.0;Platform/Android;OS/7.0;Density/2.0;Device/samsung-SM-T710;Locale/en-US;TimeZone/GMT-07:00',
+            },
+        }), options);
+        this.sessionId = sessionId;
+        this.addSubscriptions(this.onWsOpen.subscribe(() => {
+            (0, util_1.logDebug)(`WebSocket connected for ${camera.name}`);
+        }));
+    }
+    handleMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (message.method) {
+                case 'sdp':
+                    const answer = yield this.pc.createAnswer(message);
+                    this.sendSessionMessage('sdp', answer);
+                    this.onCallAnswered.next(message.sdp);
+                    this.sendSessionMessage('stream_options', {
+                        audio_enabled: true,
+                        video_enabled: true,
+                    });
+                    return;
+                case 'ice':
+                    yield this.pc.addIceCandidate({
+                        candidate: message.ice,
+                        sdpMLineIndex: message.mlineindex,
+                    });
+                    return;
+            }
+        });
+    }
+    sendSessionMessage(method, body = {}) {
+        this.sendMessage(Object.assign(Object.assign({}, body), { method }));
+    }
+}
+exports.WebrtcConnection = WebrtcConnection;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ring-client-api",
-  "version": "10.0.0-beta.5",
+  "version": "10.0.0-beta.8",
   "description": "Unofficial API for Ring doorbells, cameras, security alarm system and smart lighting",
   "main": "lib/api/index.js",
   "bin": {
@@ -14,13 +14,13 @@
     "watch:tests": "jest --watch",
     "lint": "eslint '**/*.ts' --fix",
     "build": "rm -rf lib && tsc --declaration",
-    "build-quick": "rm -rf lib && esbuild ./{api,examples,homebridge}/*.ts --target=es2017 --format=cjs --outdir=lib",
-    "example": "npm run build-quick && node ./lib/examples/example.js",
-    "api-example": "npm run build-quick && node ./lib/examples/api-example.js",
-    "record-example": "npm run build-quick && node ./lib/examples/record-example.js",
-    "return-audio-example": "npm run build-quick && node ./lib/examples/return-audio-example.js",
-    "stream-example": "npm run build-quick && node ./lib/examples/stream-example.js",
-    "browser-example": "npm run build-quick && node ./lib/examples/browser-example.js",
+    "build-quick": "rm -rf lib && esbuild ./{api,examples,homebridge}/*.ts ./api/streaming/*.ts --target=es2017 --format=cjs --outdir=lib",
+    "example": "node -r @swc-node/register ./lib/examples/example.js",
+    "api-example": "node -r @swc-node/register ./lib/examples/api-example.js",
+    "record-example": "node -r @swc-node/register ./lib/examples/record-example.js",
+    "return-audio-example": "node -r @swc-node/register ./lib/examples/return-audio-example.js",
+    "stream-example": "node -r @swc-node/register ./lib/examples/stream-example.js",
+    "browser-example": "node -r @swc-node/register ./lib/examples/browser-example.js",
     "auth-cli": "npm run build-quick && ./ring-auth-cli.js",
     "device-data-cli": "npm run build-quick && ./ring-device-data-cli.js",
     "hb": "npm run build-quick && ./build/package-homebridge.sh && homebridge -P ./release-homebridge -U ./.homebridge",
@@ -56,44 +56,45 @@
   "license": "MIT",
   "dependencies": {
     "@eneris/push-receiver": "^3.0.1",
-    "@homebridge/camera-utils": "2.1.0",
-    "@homebridge/plugin-ui-utils": "0.0.19",
+    "@homebridge/camera-utils": "^2.1.0",
+    "@homebridge/plugin-ui-utils": "^0.0.19",
     "@koush/werift": "0.14.5-beta9",
     "@types/socket.io-client": "1.4.36",
-    "colors": "1.4.0",
-    "debug": "4.3.4",
-    "got": "11.8.3",
-    "rxjs": "7.5.5",
-    "socket.io-client": "2.4.0",
-    "systeminformation": "5.11.9",
-    "uuid": "8.3.2",
-    "ws": "8.5.0"
+    "colors": "^1.4.0",
+    "debug": "^4.3.4",
+    "got": "^11.8.3",
+    "rxjs": "^7.5.5",
+    "socket.io-client": "^2.4.0",
+    "systeminformation": "^5.11.14",
+    "uuid": "^8.3.2",
+    "ws": "^8.6.0"
   },
   "devDependencies": {
+    "@swc-node/register": "^1.5.1",
     "@types/debug": "4.1.7",
-    "@types/jest": "27.4.1",
-    "@types/node": "17.0.23",
+    "@types/jest": "27.5.0",
+    "@types/node": "17.0.31",
     "@types/uuid": "8.3.4",
     "@types/ws": "^8.5.3",
-    "@typescript-eslint/eslint-plugin": "5.18.0",
-    "@typescript-eslint/parser": "5.18.0",
+    "@typescript-eslint/eslint-plugin": "5.22.0",
+    "@typescript-eslint/parser": "5.22.0",
     "concurrently": "^7.1.0",
     "conventional-github-releaser": "3.1.5",
     "dotenv": "16.0.0",
-    "esbuild": "^0.14.34",
-    "eslint": "8.13.0",
+    "esbuild": "^0.14.38",
+    "eslint": "8.14.0",
     "eslint-config-prettier": "8.5.0",
-    "eslint-plugin-jest": "26.1.4",
+    "eslint-plugin-jest": "26.1.5",
     "eslint-plugin-prettier": "4.0.0",
-    "express": "4.17.3",
-    "homebridge": "1.4.0",
-    "jest": "27.5.1",
+    "express": "4.18.1",
+    "homebridge": "1.4.1",
+    "jest": "28.1.0",
     "prettier": "2.6.2",
     "reflect-metadata": "0.1.13",
     "rimraf": "3.0.2",
     "standard-version": "9.3.2",
-    "ts-jest": "27.1.4",
-    "typescript": "4.6.3"
+    "ts-jest": "28.0.1",
+    "typescript": "4.6.4"
   },
   "engines": {
     "node": "^12.20 || ^14 || ^16",

package/lib/api/live-call-ring-edge.d.ts

@@ -1,41 +0,0 @@
-import { ReplaySubject } from 'rxjs';
-import { RingCamera } from './ring-camera';
-import { Subscribed } from './subscribed';
-import { RtpPacket } from '@koush/werift';
-declare type SpawnInput = string | number;
-export interface FfmpegOptions {
-    input?: SpawnInput[];
-    video?: SpawnInput[] | false;
-    audio?: SpawnInput[];
-    output: SpawnInput[];
-}
-export declare class LiveCallRingEdge extends Subscribed {
-    private camera;
-    private readonly ws;
-    private readonly onWsOpen;
-    private readonly onMessage;
-    private readonly pc;
-    readonly onSessionId: ReplaySubject<string>;
-    readonly onCallAnswered: ReplaySubject<string>;
-    readonly onCallEnded: ReplaySubject<void>;
-    private readonly audioSplitter;
-    private readonly videoSplitter;
-    readonly onVideoRtp: import("rxjs").Subject<RtpPacket>;
-    readonly onAudioRtp: import("rxjs").Subject<RtpPacket>;
-    private readonly onOfferSent;
-    constructor(authToken: string, camera: RingCamera);
-    private initiateCall;
-    private sessionId;
-    private handleMessage;
-    reservePort(bufferPorts?: number): Promise<number>;
-    startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
-    activated: boolean;
-    activate(): Promise<void>;
-    activateCameraSpeaker(): Promise<void>;
-    private sendSessionMessage;
-    private sendMessage;
-    private callEnded;
-    stop(): void;
-    sendAudioPacket(rtp: RtpPacket): void;
-}
-export {};