ring-client-api 13.2.1 → 14.0.0-beta.1

package/lib/streaming/streaming-session.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamingSession = void 0;
-const werift_1 = require("werift");
-const camera_utils_1 = require("@homebridge/camera-utils");
-const rxjs_1 = require("rxjs");
-const ffmpeg_1 = require("../ffmpeg");
-const util_1 = require("../util");
-const operators_1 = require("rxjs/operators");
-const subscribed_1 = require("../subscribed");
+import { RtpPacket } from 'werift';
+import { FfmpegProcess, reservePorts, RtpSplitter, } from '@homebridge/camera-utils';
+import { firstValueFrom, ReplaySubject, Subject } from 'rxjs';
+import { getFfmpegPath } from "../ffmpeg.js";
+import { logDebug, logError } from "../util.js";
+import { concatMap, map, mergeWith, take } from 'rxjs/operators';
+import { Subscribed } from "../subscribed.js";
 function getCleanSdp(sdp, includeVideo) {
     return sdp
         .split('\nm=')
@@ -16,16 +13,16 @@ function getCleanSdp(sdp, includeVideo) {
         .filter((section) => includeVideo || !section.startsWith('m=video'))
         .join('\n');
 }
-class StreamingSession extends subscribed_1.Subscribed {
+export class StreamingSession extends Subscribed {
+    onCallEnded = new ReplaySubject(1);
+    onUsingOpus = new ReplaySubject(1);
+    onVideoRtp = new Subject();
+    onAudioRtp = new Subject();
+    audioSplitter = new RtpSplitter();
+    videoSplitter = new RtpSplitter();
+    returnAudioSplitter = new RtpSplitter();
     camera;
     connection;
-    onCallEnded = new rxjs_1.ReplaySubject(1);
-    onUsingOpus = new rxjs_1.ReplaySubject(1);
-    onVideoRtp = new rxjs_1.Subject();
-    onAudioRtp = new rxjs_1.Subject();
-    audioSplitter = new camera_utils_1.RtpSplitter();
-    videoSplitter = new camera_utils_1.RtpSplitter();
-    returnAudioSplitter = new camera_utils_1.RtpSplitter();
     constructor(camera, connection) {
         super();
         this.camera = camera;
@@ -53,11 +50,11 @@ class StreamingSession extends subscribed_1.Subscribed {
         this.connection.activateCameraSpeaker();
     }
     async reservePort(bufferPorts = 0) {
-        const ports = await (0, camera_utils_1.reservePorts)({ count: bufferPorts + 1 });
+        const ports = await reservePorts({ count: bufferPorts + 1 });
         return ports[0];
     }
     get isUsingOpus() {
-        return (0, rxjs_1.firstValueFrom)(this.onUsingOpus.pipe((0, operators_1.mergeWith)(this.connection.onError.pipe((0, operators_1.map)((e) => {
+        return firstValueFrom(this.onUsingOpus.pipe(mergeWith(this.connection.onError.pipe(map((e) => {
             throw e;
         })))));
     }
@@ -66,11 +63,11 @@ class StreamingSession extends subscribed_1.Subscribed {
             return;
         }
         const videoPort = await this.reservePort(1), audioPort = await this.reservePort(1), transcodeVideoStream = ffmpegOptions.video !== false, ringSdp = await Promise.race([
-            (0, rxjs_1.firstValueFrom)(this.connection.onCallAnswered),
-            (0, rxjs_1.firstValueFrom)(this.onCallEnded),
+            firstValueFrom(this.connection.onCallAnswered),
+            firstValueFrom(this.onCallEnded),
         ]);
         if (!ringSdp) {
-            (0, util_1.logDebug)('Call ended before answered');
+            logDebug('Call ended before answered');
             return;
         }
         const usingOpus = await this.isUsingOpus, ffmpegInputArguments = [
@@ -86,21 +83,21 @@ class StreamingSession extends subscribed_1.Subscribed {
             'pipe:',
         ], inputSdp = getCleanSdp(ringSdp, transcodeVideoStream)
             .replace(/m=audio \d+/, `m=audio ${audioPort}`)
-            .replace(/m=video \d+/, `m=video ${videoPort}`), ff = new camera_utils_1.FfmpegProcess({
+            .replace(/m=video \d+/, `m=video ${videoPort}`), ff = new FfmpegProcess({
             ffmpegArgs: ffmpegInputArguments.concat(...(ffmpegOptions.audio || ['-acodec', 'aac']), ...(transcodeVideoStream
                 ? ffmpegOptions.video || ['-vcodec', 'copy']
                 : []), ...(ffmpegOptions.output || [])),
-            ffmpegPath: (0, ffmpeg_1.getFfmpegPath)(),
+            ffmpegPath: getFfmpegPath(),
             stdoutCallback: ffmpegOptions.stdoutCallback,
             exitCallback: () => this.callEnded(),
             logLabel: `From Ring (${this.camera.name})`,
             logger: {
-                error: util_1.logError,
-                info: util_1.logDebug,
+                error: logError,
+                info: logDebug,
             },
         });
         this.addSubscriptions(this.onAudioRtp
-            .pipe((0, operators_1.concatMap)((rtp) => {
+            .pipe(concatMap((rtp) => {
             return this.audioSplitter.send(rtp.serialize(), {
                 port: audioPort,
             });
@@ -108,14 +105,14 @@ class StreamingSession extends subscribed_1.Subscribed {
             .subscribe());
         if (transcodeVideoStream) {
             this.addSubscriptions(this.onVideoRtp
-                .pipe((0, operators_1.concatMap)((rtp) => {
+                .pipe(concatMap((rtp) => {
                 return this.videoSplitter.send(rtp.serialize(), {
                     port: videoPort,
                 });
             }))
                 .subscribe());
         }
-        this.onCallEnded.pipe((0, operators_1.take)(1)).subscribe(() => ff.stop());
+        this.onCallEnded.pipe(take(1)).subscribe(() => ff.stop());
         ff.writeStdin(inputSdp);
         // Request a key frame now that ffmpeg is ready to receive
         this.requestKeyFrame();
@@ -124,11 +121,11 @@ class StreamingSession extends subscribed_1.Subscribed {
         if (this.hasEnded) {
             return;
         }
-        const audioOutForwarder = new camera_utils_1.RtpSplitter(({ message }) => {
-            const rtp = werift_1.RtpPacket.deSerialize(message);
+        const audioOutForwarder = new RtpSplitter(({ message }) => {
+            const rtp = RtpPacket.deSerialize(message);
             this.connection.sendAudioPacket(rtp);
             return null;
-        }), usingOpus = await this.isUsingOpus, ff = new camera_utils_1.FfmpegProcess({
+        }), usingOpus = await this.isUsingOpus, ff = new FfmpegProcess({
             ffmpegArgs: [
                 '-hide_banner',
                 '-protocol_whitelist',
@@ -146,15 +143,15 @@ class StreamingSession extends subscribed_1.Subscribed {
                 'rtp',
                 `rtp://127.0.0.1:${await audioOutForwarder.portPromise}`,
             ],
-            ffmpegPath: (0, ffmpeg_1.getFfmpegPath)(),
+            ffmpegPath: getFfmpegPath(),
             exitCallback: () => this.callEnded(),
             logLabel: `Return Audio (${this.camera.name})`,
             logger: {
-                error: util_1.logError,
-                info: util_1.logDebug,
+                error: logError,
+                info: logDebug,
             },
         });
-        this.onCallEnded.pipe((0, operators_1.take)(1)).subscribe(() => ff.stop());
+        this.onCallEnded.pipe(take(1)).subscribe(() => ff.stop());
     }
     hasEnded = false;
     callEnded() {
@@ -182,4 +179,3 @@ class StreamingSession extends subscribed_1.Subscribed {
         this.connection.requestKeyFrame();
     }
 }
-exports.StreamingSession = StreamingSession;

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

@@ -1,13 +1,12 @@
 import { ReplaySubject, Subject } from 'rxjs';
-import { RingCamera } from '../ring-camera';
-import { BasicPeerConnection } from './peer-connection';
-import { Subscribed } from '../subscribed';
-import { RtpPacket } from 'werift';
+import type { RingCamera } from '../ring-camera.ts';
+import { type BasicPeerConnection } from './peer-connection.ts';
+import { Subscribed } from '../subscribed.ts';
+import type { RtpPacket } from 'werift';
 export interface StreamingConnectionOptions {
     createPeerConnection?: () => BasicPeerConnection;
 }
 export declare class WebrtcConnection extends Subscribed {
-    private camera;
     private readonly onSessionId;
     private readonly onOfferSent;
     private readonly dialogId;
@@ -23,6 +22,7 @@ export declare class WebrtcConnection extends Subscribed {
     readonly onVideoRtp: Subject<RtpPacket>;
     private readonly pc;
     private readonly ws;
+    private camera;
     constructor(ticket: string, camera: RingCamera, options: StreamingConnectionOptions);
     private initiateCall;
     private sessionId;

package/lib/streaming/webrtc-connection.js

@@ -1,31 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebrtcConnection = void 0;
-const ws_1 = require("ws");
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-const util_1 = require("../util");
-const peer_connection_1 = require("./peer-connection");
-const subscribed_1 = require("../subscribed");
-class WebrtcConnection extends subscribed_1.Subscribed {
-    camera;
-    onSessionId = new rxjs_1.ReplaySubject(1);
-    onOfferSent = new rxjs_1.ReplaySubject(1);
-    dialogId = (0, util_1.generateUuid)();
-    onCameraConnected = new rxjs_1.ReplaySubject(1);
-    onCallAnswered = new rxjs_1.ReplaySubject(1);
-    onCallEnded = new rxjs_1.ReplaySubject(1);
-    onError = new rxjs_1.ReplaySubject(1);
-    onMessage = new rxjs_1.ReplaySubject();
+import { WebSocket } from 'ws';
+import { firstValueFrom, fromEvent, interval, ReplaySubject, Subject, } from 'rxjs';
+import { concatMap, take } from 'rxjs/operators';
+import { generateUuid, logDebug, logError, logInfo } from "../util.js";
+import { WeriftPeerConnection, } from "./peer-connection.js";
+import { Subscribed } from "../subscribed.js";
+export class WebrtcConnection extends Subscribed {
+    onSessionId = new ReplaySubject(1);
+    onOfferSent = new ReplaySubject(1);
+    dialogId = generateUuid();
+    onCameraConnected = new ReplaySubject(1);
+    onCallAnswered = new ReplaySubject(1);
+    onCallEnded = new ReplaySubject(1);
+    onError = new ReplaySubject(1);
+    onMessage = new ReplaySubject();
     onWsOpen;
     onAudioRtp;
     onVideoRtp;
     pc;
     ws;
+    camera;
     constructor(ticket, camera, options) {
         super();
         this.camera = camera;
-        this.ws = new ws_1.WebSocket(`wss://api.prod.signalling.ring.devices.a2z.com:443/ws?api_version=4.0&auth_type=ring_solutions&client_id=ring_site-${(0, util_1.generateUuid)()}&token=${ticket}`, {
+        this.ws = new WebSocket(`wss://api.prod.signalling.ring.devices.a2z.com:443/ws?api_version=4.0&auth_type=ring_solutions&client_id=ring_site-${generateUuid()}&token=${ticket}`, {
             headers: {
                 // This must exist or the socket will close immediately but content does not seem to matter
                 'User-Agent': 'android:com.ringapp',
@@ -35,20 +32,20 @@ class WebrtcConnection extends subscribed_1.Subscribed {
             // 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();
+            this.onAudioRtp = new Subject();
+            this.onVideoRtp = new Subject();
         }
         else {
             // no custom peer connection factory, use the werift and pass along rtp packets
-            const pc = new peer_connection_1.WeriftPeerConnection();
+            const pc = new 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.onWsOpen = fromEvent(this.ws, 'open');
+        const onMessage = fromEvent(this.ws, 'message'), onError = fromEvent(this.ws, 'error'), onClose = fromEvent(this.ws, 'close');
         this.addSubscriptions(onMessage
-            .pipe((0, operators_1.concatMap)((event) => {
+            .pipe(concatMap((event) => {
             const message = JSON.parse(event.data);
             this.onMessage.next(message);
             return this.handleMessage(message).catch((e) => {
@@ -61,35 +58,35 @@ class WebrtcConnection extends subscribed_1.Subscribed {
             });
         }))
             .subscribe(), onError.subscribe((e) => {
-            (0, util_1.logError)(e);
+            logError(e);
             this.callEnded();
         }), onClose.subscribe(() => {
             this.callEnded();
         }), this.pc.onConnectionState.subscribe((state) => {
             if (state === 'failed') {
-                (0, util_1.logError)('Stream connection failed');
+                logError('Stream connection failed');
                 this.callEnded();
             }
             if (state === 'closed') {
-                (0, util_1.logDebug)('Stream connection closed');
+                logDebug('Stream connection closed');
                 this.callEnded();
             }
         }), this.onError.subscribe((e) => {
-            (0, util_1.logError)(e);
+            logError(e);
             this.callEnded();
         }), this.onWsOpen.subscribe(() => {
             const connectionType = camera.isRingEdgeEnabled ? 'Ring Edge' : 'Cloud';
-            (0, util_1.logDebug)(`WebSocket connected for ${camera.name} (${connectionType})`);
+            logDebug(`WebSocket connected for ${camera.name} (${connectionType})`);
             this.initiateCall().catch((e) => {
-                (0, util_1.logError)(e);
+                logError(e);
                 this.callEnded();
             });
         }), 
         // The ring-edge session needs a ping every 5 seconds to keep the connection alive
-        (0, rxjs_1.interval)(5000).subscribe(() => {
+        interval(5000).subscribe(() => {
             this.sendSessionMessage('ping');
         }), this.pc.onIceCandidate.subscribe(async (iceCandidate) => {
-            await (0, rxjs_1.firstValueFrom)(this.onOfferSent);
+            await firstValueFrom(this.onOfferSent);
             this.sendMessage({
                 method: 'ice',
                 dialog_id: this.dialogId,
@@ -161,8 +158,8 @@ class WebrtcConnection extends subscribed_1.Subscribed {
                 break;
             }
             case 'close':
-                (0, util_1.logError)('Video stream closed');
-                (0, util_1.logError)(message.body);
+                logError('Video stream closed');
+                logError(message.body);
                 this.callEnded();
                 return;
             case 'camera_started':
@@ -170,8 +167,8 @@ class WebrtcConnection extends subscribed_1.Subscribed {
                 // ignore these messages as we don't use them
                 return;
         }
-        (0, util_1.logError)('UNKNOWN MESSAGE');
-        (0, util_1.logError)(message);
+        logError('UNKNOWN MESSAGE');
+        logError(message);
     }
     sendSessionMessage(method, body = {}) {
         const sendSessionMessage = (sessionId) => {
@@ -193,7 +190,7 @@ class WebrtcConnection extends subscribed_1.Subscribed {
         }
         else {
             // Otherwise wait for the session id to be set and then send the message
-            this.addSubscriptions(this.onSessionId.pipe((0, operators_1.take)(1)).subscribe(sendSessionMessage));
+            this.addSubscriptions(this.onSessionId.pipe(take(1)).subscribe(sendSessionMessage));
         }
     }
     sendMessage(message) {
@@ -206,7 +203,7 @@ class WebrtcConnection extends subscribed_1.Subscribed {
         if (this.hasEnded) {
             return;
         }
-        if (this.pc instanceof peer_connection_1.WeriftPeerConnection) {
+        if (this.pc instanceof WeriftPeerConnection) {
             this.pc.returnAudioTrack.writeRtp(rtp);
         }
         else {
@@ -214,7 +211,7 @@ class WebrtcConnection extends subscribed_1.Subscribed {
         }
     }
     activate() {
-        (0, util_1.logInfo)('Activating Session');
+        logInfo('Activating Session');
         // the activate_session message is required to keep the stream alive longer than 70 seconds
         this.sendSessionMessage('activate_session');
         this.sendSessionMessage('stream_options', {
@@ -224,7 +221,7 @@ class WebrtcConnection extends subscribed_1.Subscribed {
     }
     activateCameraSpeaker() {
         // Fire and forget this call so that callers don't get hung up waiting for answer (which might not happen)
-        this.addSubscriptions(this.onCameraConnected.pipe((0, operators_1.take)(1)).subscribe(() => {
+        this.addSubscriptions(this.onCameraConnected.pipe(take(1)).subscribe(() => {
             this.sendSessionMessage('camera_options', {
                 stealth_mode: false,
             });
@@ -257,4 +254,3 @@ class WebrtcConnection extends subscribed_1.Subscribed {
         this.pc.requestKeyFrame?.();
     }
 }
-exports.WebrtcConnection = WebrtcConnection;

package/lib/subscribed.d.ts

@@ -1,4 +1,4 @@
-import { Subscription } from 'rxjs';
+import type { Subscription } from 'rxjs';
 export declare class Subscribed {
     private readonly subscriptions;
     addSubscriptions(...subscriptions: Subscription[]): void;

package/lib/subscribed.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Subscribed = void 0;
-class Subscribed {
+export class Subscribed {
     subscriptions = [];
     addSubscriptions(...subscriptions) {
         this.subscriptions.push(...subscriptions);
@@ -10,4 +7,3 @@ class Subscribed {
         this.subscriptions.forEach((subscription) => subscription.unsubscribe());
     }
 }
-exports.Subscribed = Subscribed;

package/lib/test/rest-client.spec.js

@@ -1,17 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const msw_1 = require("msw");
-const node_1 = require("msw/node");
-const rest_client_1 = require("../rest-client");
-const util_1 = require("../util");
-const rxjs_1 = require("rxjs");
+import { http, HttpResponse } from 'msw';
+import { setupServer } from 'msw/node';
+import { RingRestClient } from "../rest-client.js";
+import { clearTimeouts, getHardwareId, toBase64 } from "../util.js";
+import { firstValueFrom } from 'rxjs';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, } from 'vitest';
 let sessionCreatedCount = 0, client;
-const email = 'some@one.com', password = 'abc123!', phone = '+1xxxxxxxx89', twoFactorAuthCode = '123456', hardwareIdPromise = (0, util_1.getHardwareId)(), accessToken = 'ey__accees_token', secondAccessToken = 'ey__second_accees_token', refreshToken = 'ey__refresh_token', secondRefreshToken = 'ey__second_refresh_token', thirdRefreshToken = 'ey__third_refresh_token', server = (0, node_1.setupServer)(msw_1.http.post('https://oauth.ring.com/oauth/token', async ({ request: req }) => {
+const email = 'some@one.com', password = 'abc123!', phone = '+1xxxxxxxx89', twoFactorAuthCode = '123456', hardwareIdPromise = getHardwareId(), accessToken = 'ey__accees_token', secondAccessToken = 'ey__second_accees_token', refreshToken = 'ey__refresh_token', secondRefreshToken = 'ey__second_refresh_token', thirdRefreshToken = 'ey__third_refresh_token', server = setupServer(http.post('https://oauth.ring.com/oauth/token', async ({ request: req }) => {
     const body = await req.json();
     if (req.headers.get('2fa-support') !== 'true' ||
         req.headers.get('User-Agent') !== 'android:com.ringapp' ||
         req.headers.get('hardware_id') !== (await hardwareIdPromise)) {
-        return msw_1.HttpResponse.json({
+        return HttpResponse.json({
             code: 1,
             error: 'Invalid auth headers: ' + JSON.stringify(req.headers, null, 2),
         }, { status: 400 });
@@ -19,7 +18,7 @@ const email = 'some@one.com', password = 'abc123!', phone = '+1xxxxxxxx89', twoF
     if (body.grant_type === 'refresh_token') {
         if (body.refresh_token === refreshToken) {
             // Valid refresh token
-            return msw_1.HttpResponse.json({
+            return HttpResponse.json({
                 access_token: accessToken,
                 expires_in: 3600,
                 refresh_token: secondRefreshToken,
@@ -29,7 +28,7 @@ const email = 'some@one.com', password = 'abc123!', phone = '+1xxxxxxxx89', twoF
         }
         if (body.refresh_token === secondRefreshToken) {
             // Valid refresh token
-            return msw_1.HttpResponse.json({
+            return HttpResponse.json({
                 access_token: secondAccessToken,
                 expires_in: 3600,
                 refresh_token: thirdRefreshToken,
@@ -38,7 +37,7 @@ const email = 'some@one.com', password = 'abc123!', phone = '+1xxxxxxxx89', twoF
             }, { status: 200 });
         }
         // Invalid refresh token
-        return msw_1.HttpResponse.json({
+        return HttpResponse.json({
             error: 'invalid_grant',
             error_description: 'token is invalid or does not exists',
         }, { status: 401 });
@@ -46,14 +45,14 @@ const email = 'some@one.com', password = 'abc123!', phone = '+1xxxxxxxx89', twoF
     if (body.grant_type !== 'password' ||
         body.client_id !== 'ring_official_android' ||
         body.scope !== 'client') {
-        return msw_1.HttpResponse.json({
+        return HttpResponse.json({
             code: 1,
             error: 'Invalid auth request: ' + JSON.stringify(body),
         }, { status: 400 });
     }
     if (body.username !== email || body.password !== password) {
         // Wrong username or password
-        return msw_1.HttpResponse.json({
+        return HttpResponse.json({
             error: 'access_denied',
             error_description: 'invalid user credentials',
         }, { status: 401 });
@@ -61,14 +60,14 @@ const email = 'some@one.com', password = 'abc123!', phone = '+1xxxxxxxx89', twoF
     if (req.headers.get('2fa-code') &&
         req.headers.get('2fa-code') !== twoFactorAuthCode) {
         // Wrong 2fa code
-        return msw_1.HttpResponse.json({
+        return HttpResponse.json({
             err_msg: 'bad request response from dependency service',
             error: 'Verification Code is invalid or expired',
         }, { status: 400 });
     }
     if (req.headers.get('2fa-code') === twoFactorAuthCode) {
         // Successfull login with correct 2fa code
-        return msw_1.HttpResponse.json({
+        return HttpResponse.json({
             access_token: accessToken,
             expires_in: 3600,
             refresh_token: refreshToken,
@@ -78,35 +77,35 @@ const email = 'some@one.com', password = 'abc123!', phone = '+1xxxxxxxx89', twoF
         });
     }
     // 2fa code not provided, so return the 2fa prompt
-    return msw_1.HttpResponse.json({
+    return HttpResponse.json({
         next_time_in_secs: 60,
         phone,
         tsv_state: 'sms',
     }, { status: 412 });
-}), msw_1.http.post('https://api.ring.com/clients_api/session', async ({ request: req }) => {
+}), http.post('https://api.ring.com/clients_api/session', async ({ request: req }) => {
     const authHeader = req.headers.get('Authorization');
     if (authHeader !== `Bearer ${accessToken}` &&
         authHeader !== `Bearer ${secondAccessToken}`) {
         // Invalid access token used
-        return msw_1.HttpResponse.json({}, { status: 401 });
+        return HttpResponse.json({}, { status: 401 });
     }
     const body = await req.json();
-    if (body.device.hardware_id !== (await (0, util_1.getHardwareId)()) ||
+    if (body.device.hardware_id !== (await getHardwareId()) ||
         body.device.metadata.api_version !== 11 ||
         body.device.metadata.device_model !== 'ring-client-api' ||
         body.device.os !== 'android') {
-        return msw_1.HttpResponse.text('Bad session request: ' + JSON.stringify(body, null, 2), { status: 400 });
+        return HttpResponse.text('Bad session request: ' + JSON.stringify(body, null, 2), { status: 400 });
     }
     // Fake a response from the session endpoint, incrementing the sessionCreatedCount
     sessionCreatedCount++;
-    return msw_1.HttpResponse.json({
+    return HttpResponse.json({
         profile: {
             id: 1234,
         },
     });
 }));
 async function wrapRefreshToken(rt) {
-    return (0, util_1.toBase64)(JSON.stringify({
+    return toBase64(JSON.stringify({
         rt,
         hid: await hardwareIdPromise,
     }));
@@ -125,11 +124,11 @@ afterAll(() => {
 });
 afterEach(() => {
     client.clearTimeouts();
-    (0, util_1.clearTimeouts)();
+    clearTimeouts();
 });
 describe('getAuth', () => {
-    test('It should throw and set the 2fa prompt', async () => {
-        client = new rest_client_1.RingRestClient({
+    it('should throw and set the 2fa prompt', async () => {
+        client = new RingRestClient({
             password,
             email,
         });
@@ -137,8 +136,8 @@ describe('getAuth', () => {
         expect(client.promptFor2fa).toEqual(`Please enter the code sent to ${phone} via sms`);
         expect(client.using2fa).toEqual(true);
     });
-    test('It should accept a 2fa code', async () => {
-        client = new rest_client_1.RingRestClient({
+    it('should accept a 2fa code', async () => {
+        client = new RingRestClient({
             password,
             email,
         });
@@ -152,26 +151,26 @@ describe('getAuth', () => {
         });
         expect(client.refreshToken).toEqual(await wrapRefreshToken(refreshToken));
     });
-    test('it should handle invalid credentials', async () => {
-        client = new rest_client_1.RingRestClient({
+    it('should handle invalid credentials', async () => {
+        client = new RingRestClient({
             password: 'incorrect password',
             email,
         });
         await expect(() => client.getAuth()).rejects.toThrow('Failed to fetch oauth token from Ring. Verify that your email and password are correct. (error: access_denied)');
     });
-    test('it should handle invalid 2fa code', async () => {
-        client = new rest_client_1.RingRestClient({
+    it('should handle invalid 2fa code', async () => {
+        client = new RingRestClient({
             password,
             email,
         });
-        // ignore the first reject, it's tested above
+        // ignore the first reject, it's it('ove
         await expect(() => client.getAuth()).rejects.toThrow();
         // call getAuth again with an invalid 2fa code, which should fail
         await expect(() => client.getAuth('invalid 2fa code')).rejects.toThrow('Verification Code is invalid or expired');
         expect(client.promptFor2fa).toEqual('Invalid 2fa code entered.  Please try again.');
     });
-    test('it should establish a valid auth token with a valid refresh token', async () => {
-        client = new rest_client_1.RingRestClient({
+    it('should establish a valid auth token with a valid refresh token', async () => {
+        client = new RingRestClient({
             refreshToken,
         });
         expect(await client.getCurrentAuth()).toMatchObject({
@@ -180,11 +179,11 @@ describe('getAuth', () => {
         });
         expect(client.refreshToken).toEqual(await wrapRefreshToken(secondRefreshToken));
     });
-    test('it should emit an event when a new refresh token is created', async () => {
-        client = new rest_client_1.RingRestClient({
+    it('should emit an event when a new refresh token is created', async () => {
+        client = new RingRestClient({
             refreshToken,
         });
-        const refreshedPromise = (0, rxjs_1.firstValueFrom)(client.onRefreshTokenUpdated), auth = await client.getAuth();
+        const refreshedPromise = firstValueFrom(client.onRefreshTokenUpdated), auth = await client.getAuth();
         expect(auth).toMatchObject({
             access_token: accessToken,
             refresh_token: await wrapRefreshToken(secondRefreshToken),
@@ -199,29 +198,29 @@ describe('fetch', () => {
     let invalidateFirstAccessToken = false;
     beforeEach(() => {
         invalidateFirstAccessToken = false;
-        server.use(msw_1.http.get('https://api.ring.com/clients_api/some_endpoint', ({ request: req }) => {
+        server.use(http.get('https://api.ring.com/clients_api/some_endpoint', ({ request: req }) => {
             const authHeader = req.headers.get('Authorization');
             if (invalidateFirstAccessToken &&
                 authHeader === `Bearer ${accessToken}`) {
                 // Original access token used, but no longer valid
-                return msw_1.HttpResponse.json({}, { status: 401 });
+                return HttpResponse.json({}, { status: 401 });
             }
             if (authHeader !== `Bearer ${accessToken}` &&
                 authHeader !== `Bearer ${secondAccessToken}`) {
                 // Invalid access token used
-                return msw_1.HttpResponse.json({}, { status: 401 });
+                return HttpResponse.json({}, { status: 401 });
             }
             if (sessionCreatedCount === 0) {
                 // Session not created yet
-                return msw_1.HttpResponse.json({
+                return HttpResponse.json({
                     error: 'Session not found for ' + req.headers.get('hardware_id'),
                 }, { status: 404 });
             }
-            return msw_1.HttpResponse.json([]);
+            return HttpResponse.json([]);
         }));
     });
     it('should include the auth token as a header', async () => {
-        client = new rest_client_1.RingRestClient({
+        client = new RingRestClient({
             refreshToken,
         });
         const response = await client.request({
@@ -230,7 +229,7 @@ describe('fetch', () => {
         expect(response).toEqual([]);
     });
     it('should fetch a new auth token if the first is no longer valid', async () => {
-        client = new rest_client_1.RingRestClient({
+        client = new RingRestClient({
             refreshToken,
         });
         invalidateFirstAccessToken = true;