ring-client-api 11.4.0-beta.4 → 11.5.0

package/README.md

@@ -9,7 +9,7 @@ This is an unofficial TypeScript api for [Ring Doorbells](https://shop.ring.com/
 the [Ring Alarm System](https://shop.ring.com/pages/security-system),
 [Ring Smart Lighting](https://shop.ring.com/pages/smart-lighting),
 and third party devices that connect to the Ring Alarm System.
-Built to support the [homebridge-ring Plugin](./homebridge)
+Built to support the [homebridge-ring Plugin](../homebridge-ring)
 
 ## Installation
 

package/lib/api.d.ts

@@ -1,7 +1,7 @@
 import { RefreshTokenAuth, RingRestClient, SessionOptions } from './rest-client';
 import { Location } from './location';
-import { BaseStation, BeamBridge, CameraData, ChimeData, ProfileResponse, UserLocation } from './ring-types';
-import { RingCamera } from './ring-camera';
+import { BaseStation, BeamBridge, CameraData, ChimeData, IntercomHandsetAudioData, OnvifCameraData, ProfileResponse, ThirdPartyGarageDoorOpener, UnknownDevice, UserLocation } from './ring-types';
+import { AnyCameraData, RingCamera } from './ring-camera';
 import { Subscribed } from './subscribed';
 export interface RingApiOptions extends SessionOptions {
     locationIds?: string[];
@@ -28,9 +28,13 @@ export declare class RingApi extends Subscribed {
         chimes: ChimeData[];
         authorizedDoorbots: CameraData[];
         stickupCams: CameraData[];
-        allCameras: CameraData[];
+        allCameras: AnyCameraData[];
         baseStations: BaseStation[];
         beamBridges: BeamBridge[];
+        onvifCameras: OnvifCameraData[];
+        thirdPartyGarageDoorOpeners: ThirdPartyGarageDoorOpener[];
+        intercomHandsets: IntercomHandsetAudioData[];
+        unknownDevices: UnknownDevice[];
     }>;
     private listenForDeviceUpdates;
     registerPushReceiver(cameras: RingCamera[]): Promise<void>;

package/lib/api.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RingApi = void 0;
 const rest_client_1 = require("./rest-client");
 const location_1 = require("./location");
+const ring_types_1 = require("./ring-types");
 const ring_camera_1 = require("./ring-camera");
 const ring_chime_1 = require("./ring-chime");
 const rxjs_1 = require("rxjs");
@@ -33,15 +34,40 @@ class RingApi extends subscribed_1.Subscribed {
         }
     }
     async fetchRingDevices() {
-        const { doorbots, chimes, authorized_doorbots: authorizedDoorbots, stickup_cams: stickupCams, base_stations: baseStations, beams_bridges: beamBridges, } = await this.restClient.request({ url: (0, rest_client_1.clientApi)('ring_devices') });
+        const { doorbots, chimes, authorized_doorbots: authorizedDoorbots, stickup_cams: stickupCams, base_stations: baseStations, beams_bridges: beamBridges, other: otherDevices, } = await this.restClient.request({ url: (0, rest_client_1.clientApi)('ring_devices') }), onvifCameras = [], intercomHandsets = [], thirdPartyGarageDoorOpeners = [], unknownDevices = [];
+        otherDevices.forEach((device) => {
+            switch (device.kind) {
+                case ring_types_1.RingDeviceType.OnvifCamera:
+                    onvifCameras.push(device);
+                    break;
+                case ring_types_1.RingDeviceType.IntercomHandsetAudio:
+                    intercomHandsets.push(device);
+                    break;
+                case ring_types_1.RingDeviceType.ThirdPartyGarageDoorOpener:
+                    thirdPartyGarageDoorOpeners.push(device);
+                    break;
+                default:
+                    unknownDevices.push(device);
+                    break;
+            }
+        });
         return {
             doorbots,
             chimes,
             authorizedDoorbots,
             stickupCams,
-            allCameras: doorbots.concat(stickupCams, authorizedDoorbots),
+            allCameras: [
+                ...doorbots,
+                ...stickupCams,
+                ...authorizedDoorbots,
+                ...onvifCameras,
+            ],
             baseStations,
             beamBridges,
+            onvifCameras,
+            thirdPartyGarageDoorOpeners,
+            intercomHandsets,
+            unknownDevices,
         };
     }
     listenForDeviceUpdates(cameras, chimes) {

package/lib/ring-camera.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { CameraData, CameraDeviceSettingsData, CameraEventOptions, CameraEventResponse, CameraHealth, HistoryOptions, PeriodicFootageResponse, PushNotification, VideoSearchResponse } from './ring-types';
+import { CameraData, CameraDeviceSettingsData, CameraEventOptions, CameraEventResponse, CameraHealth, HistoryOptions, PeriodicFootageResponse, PushNotification, VideoSearchResponse, OnvifCameraData, RingCameraKind } from './ring-types';
 import { RingRestClient } from './rest-client';
 import { BehaviorSubject, Subject } from 'rxjs';
 import { DeepPartial } from './util';
@@ -7,6 +7,7 @@ import { Subscribed } from './subscribed';
 import { FfmpegOptions, StreamingSession } from './streaming/streaming-session';
 import { StreamingConnectionOptions } from './streaming/streaming-connection-base';
 import { SimpleWebRtcSession } from './streaming/simple-webrtc-session';
+export declare type AnyCameraData = CameraData | OnvifCameraData;
 export declare function getBatteryLevel(data: Pick<CameraData, 'battery_life' | 'battery_life_2'> & {
     health?: Partial<CameraData['health']>;
 }): number | null;
@@ -19,9 +20,9 @@ export declare class RingCamera extends Subscribed {
     private restClient;
     private avoidSnapshotBatteryDrain;
     id: number;
-    deviceType: import("./ring-types").RingCameraKind;
+    deviceType: RingCameraKind.onvif_camera | Omit<RingCameraKind, RingCameraKind.onvif_camera>;
     model: string;
-    onData: BehaviorSubject<CameraData>;
+    onData: BehaviorSubject<AnyCameraData>;
     hasLight: boolean;
     hasSiren: boolean;
     onRequestUpdate: Subject<unknown>;
@@ -32,10 +33,10 @@ export declare class RingCamera extends Subscribed {
     onMotionStarted: import("rxjs").Observable<null>;
     onBatteryLevel: import("rxjs").Observable<number | null>;
     onInHomeDoorbellStatus: import("rxjs").Observable<boolean>;
-    constructor(initialData: CameraData, isDoorbot: boolean, restClient: RingRestClient, avoidSnapshotBatteryDrain: boolean);
-    updateData(update: CameraData): void;
+    constructor(initialData: AnyCameraData, isDoorbot: boolean, restClient: RingRestClient, avoidSnapshotBatteryDrain: boolean);
+    updateData(update: AnyCameraData): void;
     requestUpdate(): void;
-    get data(): CameraData;
+    get data(): AnyCameraData;
     get name(): string;
     get activeNotifications(): PushNotification[];
     get latestNotification(): PushNotification | undefined;

package/lib/ring-camera.js

@@ -77,11 +77,18 @@ class RingCamera extends subscribed_1.Subscribed {
         this.fetchingSnapshot = false;
         this.id = this.initialData.id;
         this.deviceType = this.initialData.kind;
-        this.model = ring_types_1.RingCameraModel[this.initialData.kind] || 'Unknown Model';
+        this.model =
+            ring_types_1.RingCameraModel[this.initialData.kind] ||
+                'Unknown Model';
         this.onData = new rxjs_1.BehaviorSubject(this.initialData);
         this.hasLight = this.initialData.led_status !== undefined;
         this.hasSiren = this.initialData.siren_status !== undefined;
-        this.onBatteryLevel = this.onData.pipe((0, operators_1.map)(getBatteryLevel), (0, operators_1.distinctUntilChanged)());
+        this.onBatteryLevel = this.onData.pipe((0, operators_1.map)((data) => {
+            if (!('battery_level' in data)) {
+                return null;
+            }
+            return getBatteryLevel(data);
+        }), (0, operators_1.distinctUntilChanged)());
         this.onInHomeDoorbellStatus = this.onData.pipe((0, operators_1.map)(({ settings: { chime_settings } }) => {
             return Boolean(chime_settings?.enable);
         }), (0, operators_1.distinctUntilChanged)());
@@ -118,6 +125,9 @@ class RingCamera extends subscribed_1.Subscribed {
         return notifications[notifications.length - 1];
     }
     get batteryLevel() {
+        if (!('battery_level' in this.data)) {
+            return null;
+        }
         return getBatteryLevel(this.data);
     }
     get hasBattery() {
@@ -127,7 +137,10 @@ class RingCamera extends subscribed_1.Subscribed {
         return this.data.alerts.battery === 'low';
     }
     get isCharging() {
-        return this.initialData.external_connection;
+        if (!('external_connection' in this.data)) {
+            return false;
+        }
+        return this.data.external_connection;
     }
     get operatingOnBattery() {
         return this.hasBattery && this.data.settings.power_mode !== 'wired';

package/lib/ring-types.d.ts

@@ -39,7 +39,10 @@ export declare enum RingDeviceType {
     ZWaveAdapter = "adapter.zwave",
     ZWaveExtender = "range-extender.zwave",
     PanicButton = "security-panic",
-    UnknownZWave = "unknown.zwave"
+    UnknownZWave = "unknown.zwave",
+    OnvifCamera = "onvif_camera",
+    ThirdPartyGarageDoorOpener = "third_party_gdo",
+    IntercomHandsetAudio = "intercom_handset_audio"
 }
 export declare enum RingDeviceCategory {
     Outlets = 1,
@@ -88,7 +91,8 @@ export declare enum RingCameraKind {
     cocoa_camera = "cocoa_camera",
     cocoa_doorbell = "cocoa_doorbell",
     cocoa_floodlight = "cocoa_floodlight",
-    stickup_cam_mini = "stickup_cam_mini"
+    stickup_cam_mini = "stickup_cam_mini",
+    onvif_camera = "onvif_camera"
 }
 export declare const RingCameraModel: {
     readonly [P in RingCameraKind]: string;
@@ -329,23 +333,34 @@ export declare enum DoorbellType {
     Digital = 1,
     None = 2
 }
-export interface CameraData {
-    id: number;
+export interface BaseCameraData {
+    alerts: {
+        connection: 'online' | 'offline' | string;
+        battery?: 'low' | string;
+        ota_status?: 'timeout' | string;
+    };
+    created_at: string;
+    deactivated_at: null | string;
     description: string;
     device_id: string;
-    time_zone: string;
-    subscribed: boolean;
-    subscribed_motions: boolean;
-    battery_life: number | string | null;
-    battery_life_2?: number | string | null;
-    battery_voltage?: number;
-    battery_voltage_2?: number;
-    external_connection: boolean;
-    firmware_version: Firmware;
-    kind: RingCameraKind;
-    latitude: number;
-    longitude: number;
-    address: string;
+    features: {
+        motions_enabled: boolean;
+        show_recordings: boolean;
+        advanced_motion_enabled: boolean;
+        people_only_enabled: boolean;
+        shadow_correction_enabled: boolean;
+        motion_message_enabled: boolean;
+        night_vision_enabled: boolean;
+    };
+    id: number;
+    is_sidewalk_gateway: boolean;
+    location_id: string;
+    motion_snooze: null | {
+        scheduled: boolean;
+    };
+    night_mode_status: 'unknown' | 'true' | 'false';
+    owned: boolean;
+    ring_net_id: null;
     settings: {
         enable_vod: boolean | 1;
         motion_zones: {
@@ -397,26 +412,9 @@ export interface CameraData {
             ring_media_server_enabled: boolean;
         };
     };
-    features: {
-        motions_enabled: boolean;
-        show_recordings: boolean;
-        advanced_motion_enabled: boolean;
-        people_only_enabled: boolean;
-        shadow_correction_enabled: boolean;
-        motion_message_enabled: boolean;
-        night_vision_enabled: boolean;
-    };
-    owned: boolean;
-    alerts: {
-        connection: 'online' | 'offline' | string;
-        battery?: 'low' | string;
-    };
-    motion_snooze: {
-        scheduled: boolean;
-    };
-    stolen: boolean;
-    location_id: string;
-    ring_id: null;
+    subscribed: boolean;
+    subscribed_motions: boolean;
+    time_zone: string;
     motion_detection_enabled?: boolean;
     camera_location_indoor?: boolean;
     facing_window?: boolean;
@@ -428,7 +426,6 @@ export interface CameraData {
         last_name: string;
     };
     led_status?: 'on' | 'off';
-    night_mode_status: 'true' | 'false';
     ring_cam_light_installed?: 'true' | 'false';
     ring_cam_setup_flow?: 'floodlight';
     siren_status?: {
@@ -476,6 +473,144 @@ export interface CameraData {
         ptz_connected?: 'penguin';
     };
 }
+export interface CameraData extends BaseCameraData {
+    kind: Omit<RingCameraKind, RingCameraKind.onvif_camera>;
+    address: string;
+    battery_life: number | string | null;
+    battery_life_2?: number | string | null;
+    battery_voltage?: number;
+    battery_voltage_2?: number;
+    external_connection: boolean;
+    firmware_version: Firmware;
+    latitude: number;
+    longitude: number;
+    ring_id: null;
+    stolen: boolean;
+}
+export interface OnvifCameraData extends BaseCameraData {
+    kind: RingCameraKind.onvif_camera;
+    metadata: {
+        legacy_fw_migrated: boolean;
+        imported_from_amazon: boolean;
+        is_sidewalk_gateway: boolean;
+        third_party_manufacturer: string;
+        third_party_model: string;
+        third_party_dsn: string;
+        third_party_properties: {
+            amzn_dsn: string;
+            uuid: string;
+        };
+    };
+    owner_id: number;
+    updated_at: string;
+}
+export interface ThirdPartyGarageDoorOpener {
+    id: number;
+    kind: RingDeviceType.ThirdPartyGarageDoorOpener;
+    description: string;
+    location_id: string;
+    owner_id: number;
+    hardware_id: string;
+    created_at: string;
+    updated_at: string;
+    role: 'owner' | string;
+    metadata: {
+        is_sidewalk_gateway: boolean;
+        third_party_manufacturer: string;
+        third_party_model: string;
+        third_party_properties: {
+            key_access_point_associated: 'true' | 'false';
+        };
+        integration_type: 'Key by Amazon' | string;
+    };
+    ring_net_id: null;
+    is_sidewalk_gateway: boolean;
+}
+export interface IntercomHandsetAudioData {
+    id: number;
+    description: string;
+    device_id: string;
+    kind: RingDeviceType.IntercomHandsetAudio;
+    function: {
+        name: null;
+    };
+    settings: {
+        show_recordings: boolean;
+        recording_ttl: number;
+        recording_enabled: boolean;
+        keep_alive: null;
+        chime_settings: {
+            type: number;
+            enable: boolean;
+            duration: number;
+        };
+        intercom_settings: {
+            predecessor: string;
+            config: string;
+            ring_to_open: boolean;
+            intercom_type: 'DF' | string;
+            unlock_mode: number;
+            replication: number;
+        };
+        keep_alive_auto: number;
+        doorbell_volume: number;
+        enable_chime: number;
+        theft_alarm_enable: number;
+        use_cached_domain: number;
+        use_server_ip: number;
+        server_domain: 'fw.ring.com' | string;
+        server_ip: null;
+        enable_log: number;
+        forced_keep_alive: null;
+        mic_volume: number;
+        voice_volume: number;
+    };
+    features: {
+        motion_zone_recommendation: boolean;
+        motions_enabled: boolean;
+        show_recordings: boolean;
+        show_vod_settings: boolean;
+        rich_notifications_eligible: boolean;
+        show_24x7_lite: boolean;
+        show_offline_motion_events: boolean;
+        cfes_eligible: boolean;
+        sheila_camera_eligible: null | boolean;
+        sheila_camera_processing_eligible: null | boolean;
+        chime_auto_detect_capable: boolean;
+    };
+    owned: boolean;
+    owner: {
+        id: number;
+        first_name: string;
+        last_name: string;
+        email: string;
+    };
+    alerts: {
+        connection: 'online' | 'offline' | string;
+        ota_status?: 'no_ota' | string;
+    };
+    firmware_version: 'Up to Date' | string;
+    location_id: string;
+    time_zone: string;
+    created_at: string;
+    ring_net_id: null;
+    is_sidewalk_gateway: boolean;
+    subscribed: boolean;
+    deactivated_at: null | string;
+    battery_life: string;
+    metadata: {
+        ethernet: boolean;
+        legacy_fw_migrated: boolean;
+        imported_from_amazon: boolean;
+        is_sidewalk_gateway: boolean;
+        key_access_point_associated: boolean;
+    };
+}
+export interface UnknownDevice {
+    id: number;
+    kind: unknown;
+    description: string;
+}
 export interface CvDetectionType {
     enabled: boolean;
     mode: string;

package/lib/ring-types.js

@@ -44,6 +44,9 @@ var RingDeviceType;
     RingDeviceType["ZWaveExtender"] = "range-extender.zwave";
     RingDeviceType["PanicButton"] = "security-panic";
     RingDeviceType["UnknownZWave"] = "unknown.zwave";
+    RingDeviceType["OnvifCamera"] = "onvif_camera";
+    RingDeviceType["ThirdPartyGarageDoorOpener"] = "third_party_gdo";
+    RingDeviceType["IntercomHandsetAudio"] = "intercom_handset_audio";
 })(RingDeviceType = exports.RingDeviceType || (exports.RingDeviceType = {}));
 // eslint-disable-next-line no-shadow
 var RingDeviceCategory;
@@ -97,6 +100,7 @@ var RingCameraKind;
     RingCameraKind["cocoa_doorbell"] = "cocoa_doorbell";
     RingCameraKind["cocoa_floodlight"] = "cocoa_floodlight";
     RingCameraKind["stickup_cam_mini"] = "stickup_cam_mini";
+    RingCameraKind["onvif_camera"] = "onvif_camera";
 })(RingCameraKind = exports.RingCameraKind || (exports.RingCameraKind = {}));
 exports.RingCameraModel = {
     doorbot: 'Doorbell',
@@ -127,6 +131,7 @@ exports.RingCameraModel = {
     cocoa_doorbell: 'Doorbell Gen 2',
     cocoa_floodlight: 'Floodlight Cam Plus',
     stickup_cam_mini: 'Indoor Cam',
+    onvif_camera: 'ONVIF Camera',
 };
 exports.allAlarmStates = [
     'burglar-alarm',

package/lib/streaming/ring-edge-connection.js

@@ -104,6 +104,13 @@ class RingEdgeConnection extends streaming_connection_base_1.StreamingConnection
                 return;
             case 'pong':
                 return;
+            case 'notification':
+                const { text } = message.body;
+                if (text === 'PeerConnectionState::kConnecting' ||
+                    text === 'PeerConnectionState::kConnected') {
+                    return;
+                }
+                break;
             case 'close':
                 (0, util_1.logError)('Video stream closed');
                 (0, util_1.logError)(message.body);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ring-client-api",
-  "version": "11.4.0-beta.4",
+  "version": "11.5.0",
   "description": "Unofficial API for Ring doorbells, cameras, security alarm system and smart lighting",
   "main": "lib/index.js",
   "exports": {
@@ -10,7 +10,7 @@
     "./rest-client": "./lib/rest-client.js"
   },
   "scripts": {
-    "build": "rm -rf lib && tsc --declaration --excludeDirectories test",
+    "build": "rm -rf lib && tsc --declaration && chmod +x ./lib/ring-*-cli.js",
     "lint": "eslint . --ext .ts",
     "test": "jest",
     "test:watch": "jest --watch"

package/lib/test/ring-camera.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/test/ring-camera.spec.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("../index");
-describe('Ring Camera', () => {
-    describe('battery level', () => {
-        it('should handle string battery life', () => {
-            expect((0, index_1.getBatteryLevel)({
-                battery_life: '49',
-            })).toEqual(49);
-        });
-        it('should handle null battery life', () => {
-            expect((0, index_1.getBatteryLevel)({ battery_life: null })).toEqual(null);
-        });
-        it('should handle right battery only', () => {
-            expect((0, index_1.getBatteryLevel)({ battery_life: null, battery_life_2: 24 })).toEqual(24);
-        });
-        it('should handle left battery only', () => {
-            expect((0, index_1.getBatteryLevel)({ battery_life: 76, battery_life_2: null })).toEqual(76);
-        });
-        it('should handle dual batteries', () => {
-            expect((0, index_1.getBatteryLevel)({ battery_life: '92', battery_life_2: 84 })).toEqual(84);
-            expect((0, index_1.getBatteryLevel)({ battery_life: '92', battery_life_2: 100 })).toEqual(92);
-        });
-    });
-});