ring-client-api/lib/ring-types.d.ts

Unofficial API for Ring doorbells, cameras, security alarm system and smart lighting

type Firmware = string | 'Up To Date';
export declare const RingDeviceType: {
    readonly BaseStation: "hub.redsky";
    readonly BaseStationPro: "hub.kili";
    readonly Keypad: "security-keypad";
    readonly SecurityPanel: "security-panel";
    readonly ContactSensor: "sensor.contact";
    readonly MotionSensor: "sensor.motion";
    readonly FloodFreezeSensor: "sensor.flood-freeze";
    readonly FreezeSensor: "sensor.freeze";
    readonly TemperatureSensor: "sensor.temperature";
    readonly WaterSensor: "sensor.water";
    readonly TiltSensor: "sensor.tilt";
    readonly GlassbreakSensor: "sensor.glassbreak";
    readonly RangeExtender: "range-extender.zwave";
    readonly ZigbeeAdapter: "adapter.zigbee";
    readonly AccessCodeVault: "access-code.vault";
    readonly AccessCode: "access-code";
    readonly SmokeAlarm: "alarm.smoke";
    readonly CoAlarm: "alarm.co";
    readonly SmokeCoListener: "listener.smoke-co";
    readonly MultiLevelSwitch: "switch.multilevel";
    readonly Fan: "switch.multilevel";
    readonly MultiLevelBulb: "switch.multilevel.bulb";
    readonly Switch: "switch";
    readonly BeamsMotionSensor: "motion-sensor.beams";
    readonly BeamsSwitch: "switch.beams";
    readonly BeamsMultiLevelSwitch: "switch.multilevel.beams";
    readonly BeamsLightGroupSwitch: "group.light-group.beams";
    readonly BeamsTransformerSwitch: "switch.transformer.beams";
    readonly BeamsDevice: "device.beams";
    readonly RetrofitBridge: "bridge.flatline";
    readonly RetrofitZone: "sensor.zone";
    readonly Thermostat: "temperature-control.thermostat";
    readonly Sensor: "sensor";
    readonly RingNetAdapter: "adapter.ringnet";
    readonly CodeVault: "access-code.vault";
    readonly SecurityAccessCode: "access-code";
    readonly ZWaveAdapter: "adapter.zwave";
    readonly ZWaveExtender: "range-extender.zwave";
    readonly PanicButton: "security-panic";
    readonly UnknownZWave: "unknown.zwave";
    readonly OnvifCamera: "onvif_camera";
    readonly ThirdPartyGarageDoorOpener: "third_party_gdo";
    readonly IntercomHandsetAudio: "intercom_handset_audio";
    readonly WaterValve: "valve.water";
};
export type RingDeviceType = (typeof RingDeviceType)[keyof typeof RingDeviceType];
export declare const RingDeviceCategory: {
    readonly Outlets: 1;
    readonly Lights: 2;
    readonly Sensors: 5;
    readonly Appliances: 7;
    readonly Locks: 10;
    readonly Thermostats: 11;
    readonly Cameras: 12;
    readonly Alarms: 15;
    readonly Fans: 17;
    readonly Security: 22;
    readonly Unknown: 29;
    readonly SensorsMotion: 30;
    readonly Controller: 31;
    readonly RangeExtenders: 32;
    readonly Keypads: 33;
    readonly Sirens: 34;
    readonly PanicButtons: 35;
    readonly WaterValves: 37;
};
export type RingDeviceCategory = (typeof RingDeviceCategory)[keyof typeof RingDeviceCategory];
export declare const RingCameraKind: {
    readonly doorbot: "doorbot";
    readonly doorbell: "doorbell";
    readonly doorbell_v3: "doorbell_v3";
    readonly doorbell_v4: "doorbell_v4";
    readonly doorbell_v5: "doorbell_v5";
    readonly doorbell_oyster: "doorbell_oyster";
    readonly doorbell_portal: "doorbell_portal";
    readonly doorbell_scallop: "doorbell_scallop";
    readonly doorbell_scallop_lite: "doorbell_scallop_lite";
    readonly doorbell_graham_cracker: "doorbell_graham_cracker";
    readonly lpd_v1: "lpd_v1";
    readonly lpd_v2: "lpd_v2";
    readonly lpd_v4: "lpd_v4";
    readonly jbox_v1: "jbox_v1";
    readonly stickup_cam: "stickup_cam";
    readonly stickup_cam_v3: "stickup_cam_v3";
    readonly stickup_cam_elite: "stickup_cam_elite";
    readonly stickup_cam_longfin: "stickup_cam_longfin";
    readonly stickup_cam_lunar: "stickup_cam_lunar";
    readonly spotlightw_v2: "spotlightw_v2";
    readonly hp_cam_v1: "hp_cam_v1";
    readonly hp_cam_v2: "hp_cam_v2";
    readonly stickup_cam_v4: "stickup_cam_v4";
    readonly floodlight_v1: "floodlight_v1";
    readonly floodlight_v2: "floodlight_v2";
    readonly floodlight_pro: "floodlight_pro";
    readonly cocoa_camera: "cocoa_camera";
    readonly cocoa_doorbell: "cocoa_doorbell";
    readonly cocoa_doorbell_v2: "cocoa_doorbell_v2";
    readonly cocoa_doorbell_v3: "cocoa_doorbell_v3";
    readonly cocoa_floodlight: "cocoa_floodlight";
    readonly cocoa_spotlight: "cocoa_spotlight";
    readonly stickup_cam_mini: "stickup_cam_mini";
    readonly onvif_camera: "onvif_camera";
};
export type RingCameraKind = (typeof RingCameraKind)[keyof typeof RingCameraKind];
export declare const RingCameraModel: {
    readonly [P in RingCameraKind]: string;
};
export type AlarmMode = 'all' | 'some' | 'none';
export type ThermostatMode = 'heat' | 'cool' | 'off' | 'aux';
export type MessageType = 'RoomGetList' | 'SessionInfo' | 'DeviceInfoDocGetList' | 'DeviceInfoSet';
export type MessageDataType = 'RoomListV2Type' | 'SessionInfoType' | 'DeviceInfoDocType' | 'DeviceInfoSetType' | 'HubDisconnectionEventType';
export interface SocketIoMessage {
    msg: MessageType;
    datatype: MessageDataType;
    src: string;
    body: any[];
}
export type AssetKind = 'base_station_v1' | 'beams_bridge_v1' | 'floodlight_v2' | string;
export interface AssetSession {
    assetUuid: string;
    connectionStatus: 'unknown' | 'cell-backup' | 'online';
    doorbotId: number;
    kind: AssetKind;
    sessionId: number;
}
export type AlarmState = 'burglar-alarm' | 'entry-delay' | 'fire-alarm' | 'co-alarm' | 'panic' | 'user-verified-burglar-alarm' | 'user-verified-co-or-fire-alarm' | 'burglar-accelerated-alarm' | 'fire-accelerated-alarm';
export declare const allAlarmStates: AlarmState[];
export interface RingDeviceData {
    zid: string;
    name: string;
    deviceType: RingDeviceType;
    categoryId: number;
    batteryLevel?: number;
    batteryStatus: 'full' | 'charged' | 'ok' | 'low' | 'none' | 'charging';
    batteryBackup?: 'charged' | 'charging' | 'inUse';
    acStatus?: 'error' | 'ok';
    manufacturerName?: string;
    serialNumber?: string;
    tamperStatus: 'ok' | 'tamper';
    faulted?: boolean;
    locked?: 'jammed' | 'locked' | 'unlocked' | 'unknown';
    roomId?: number;
    volume?: number;
    mode?: AlarmMode | ThermostatMode;
    transitionDelayEndTimestamp?: number | null;
    alarmInfo?: {
        state: AlarmState;
        faultedDevices?: string[];
        timestamp?: number;
        uuid?: string;
    };
    siren?: {
        state: 'on' | 'off';
    };
    alarmStatus?: 'active';
    co?: {
        alarmStatus?: 'active';
    };
    smoke?: {
        alarmStatus?: 'active';
    };
    flood?: {
        faulted?: boolean;
    };
    freeze?: {
        faulted?: boolean;
    };
    motionStatus?: 'clear' | 'faulted';
    groupId?: string;
    tags: ('hidden' | 'sleepy' | 'ota-lock' | 'scanned' | 'kitted' | string)[];
    on?: boolean;
    level?: number;
    hs?: {
        hue?: number;
        sat?: number;
    };
    ct?: number;
    status?: 'enabled' | 'disabled';
    parentZid?: string;
    rootDevice?: string;
    relToParentZid?: string;
    celsius?: number;
    faultHigh?: number;
    faultLow?: number;
    setPoint?: number;
    setPointMax?: number;
    setPointMin?: number;
    basicValue?: number;
    componentDevices?: {
        rel: string;
        zid: string;
    }[];
    motionSensorEnabled?: boolean;
    brightness?: number;
    valveState?: 'open' | 'closed';
}
export declare const deviceTypesWithVolume: RingDeviceType[];
export interface BaseStation {
    address: string;
    alerts: any[];
    description: string;
    device_id: string;
    features: null;
    firmware_version: Firmware;
    id: number;
    kind: string;
    latitude: number;
    location_id: string;
    longitude: number;
    owned: boolean;
    owner?: {
        id: number;
        email: string;
        first_name: string;
        last_name: string;
    };
    ring_id: null;
    settings: null;
    stolen: boolean;
    time_zone: string;
}
export interface BeamBridge {
    created_at: string;
    description: string;
    hardware_id: string;
    id: number;
    kind: string;
    location_id: string;
    metadata: {
        ethernet: boolean;
        legacy_fw_migrated: boolean;
    };
    owner_id: number;
    role: string;
    updated_at: string;
}
export type ChimeKind = 'chime' | 'chime_pro' | 'chime_v2' | 'chime_pro_v2';
export declare const ChimeModel: {
    readonly [P in ChimeKind]: string;
};
export interface ChimeData {
    id: number;
    description: string;
    device_id: string;
    time_zone: string;
    firmware_version: Firmware;
    kind: ChimeKind;
    latitude: number;
    longitude: number;
    address: string;
    settings: {
        volume: number;
        ding_audio_user_id: string;
        ding_audio_id: string;
        motion_audio_user_id: string;
        motion_audio_id: string;
    };
    features: {
        ringtones_enabled: boolean;
    };
    owned: boolean;
    alerts: {
        connection: string;
        rssi: string;
    };
    do_not_disturb: {
        seconds_left: number;
    };
    stolen: boolean;
    location_id: string;
    ring_id: null;
    owner: {
        id: number;
        first_name: string;
        last_name: string;
        email: string;
    };
}
export type ChimeSoundKind = 'motion' | 'ding';
export interface ChimeUpdate {
    description?: string;
    latitude?: number;
    longitude?: number;
    address?: string;
    settings?: {
        volume?: number;
        ding_audio_user_id?: string;
        ding_audio_id?: string;
        motion_audio_user_id?: string;
        motion_audio_id?: string;
    };
}
export interface RingtoneOptions {
    default_ding_user_id: string;
    default_ding_id: string;
    default_motion_user_id: string;
    default_motion_id: string;
    audios: [
        {
            user_id: string;
            id: string;
            description: string;
            kind: string;
            url: string;
            checksum: string;
            available: string;
        }
    ];
}
export interface LocationAddress {
    address1: string;
    address2: string;
    cross_street: string;
    city: string;
    state: string;
    timezone: string;
    zip_code: string;
}
export interface UserLocation {
    address: LocationAddress;
    created_at: string;
    geo_coordinates: {
        latitude: string;
        longitude: string;
    };
    geo_service_verified: 'address_only' | string;
    location_id: string;
    name: string;
    owner_id: number;
    updated_at: string;
    user_verified: boolean;
}
export interface TicketAsset {
    doorbotId: number;
    kind: AssetKind;
    onBattery: boolean;
    status: 'online' | 'offline';
    uuid: string;
}
export declare const DoorbellType: {
    readonly Mechanical: 0;
    readonly Digital: 1;
    readonly None: 2;
};
export type DoorbellType = (typeof DoorbellType)[keyof typeof DoorbellType];
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;
    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: {
            enable_audio: false;
            active_motion_filter: number;
            sensitivity: number;
            advanced_object_settings: any;
            zone1: any;
            zone2: any;
            zone3: any;
        };
        motion_snooze_preset_profile: string;
        live_view_preset_profile: string;
        live_view_presets: string[];
        motion_snooze_presets: string[];
        doorbell_volume: number;
        chime_settings?: {
            type: DoorbellType;
            enable: boolean;
            duration: number;
        };
        video_settings: any;
        motion_announcement: boolean;
        stream_setting: number;
        advanced_motion_detection_enabled: boolean;
        advanced_motion_detection_human_only_mode: boolean;
        luma_night_threshold: number;
        enable_audio_recording: boolean | null;
        people_detection_eligible: false;
        pir_settings?: any;
        pir_motion_zones?: number[];
        floodlight_settings?: {
            priority: number;
            duration: number;
            brightness?: number;
            always_on: boolean;
            always_on_duration: null | number;
        };
        light_schedule_settings?: any;
        luma_light_threshold?: number;
        live_view_disabled?: boolean;
        motion_detection_enabled?: boolean;
        power_mode?: 'battery' | 'wired';
        sheila_settings: {
            cv_processing_enabled: boolean | null;
            local_storage_enabled: boolean | null;
        };
        server_settings: {
            ring_media_server_enabled: boolean;
        };
    };
    subscribed: boolean;
    subscribed_motions: boolean;
    time_zone: string;
    motion_detection_enabled?: boolean;
    camera_location_indoor?: boolean;
    facing_window?: boolean;
    enable_ir_led?: boolean;
    owner: {
        id: number;
        email: string;
        first_name: string;
        last_name: string;
    };
    led_status?: 'on' | 'off';
    ring_cam_light_installed?: 'true' | 'false';
    ring_cam_setup_flow?: 'floodlight';
    siren_status?: {
        started_at?: string;
        duration?: string;
        ends_at?: string;
        seconds_remaining: number;
    };
    health: {
        device_type: RingCameraKind;
        last_update_time: number;
        connected: boolean;
        rss_connected: boolean;
        vod_enabled: boolean;
        sidewalk_connection: boolean;
        floodlight_on: boolean;
        siren_on?: boolean;
        white_led_on: boolean;
        night_mode_on: boolean;
        hatch_open: boolean;
        packet_loss: number;
        packet_loss_category: 'good' | string;
        rssi: number;
        battery_voltage: number;
        wifi_is_ring_network: boolean;
        supported_rpc_commands: string[];
        ota_status: 'successful' | string;
        ext_power_state?: 0 | number;
        pref_run_mode?: 'low_power' | string;
        run_mode?: 'low_power' | 'full_power' | string;
        network_connection_value: 'wifi' | string;
        ac_power: number;
        battery_present?: boolean;
        external_connection: boolean;
        battery_percentage?: number;
        battery_percentage_category: 'very_good' | 'unknown' | string;
        firmware_version: string;
        rssi_category: 'good' | string;
        battery_voltage_category: 'very_good' | string;
        second_battery_voltage_category: 'unknown' | string;
        second_battery_percentage?: number;
        second_battery_percentage_category: 'unknown' | string;
        battery_save: boolean;
        firmware_version_status: 'Up to Date';
        tx_rate: number;
        ptz_connected?: 'penguin';
    };
}
export interface CameraData extends BaseCameraData {
    kind: Omit<RingCameraKind, typeof 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: typeof 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: typeof 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: typeof 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;
    notification: boolean;
}
export interface DayNightConfig {
    day: number;
    night: number;
}
export interface CameraDeviceSettingsData {
    advanced_motion_settings: {
        active_motion_filter: number;
        advanced_object_settings: {
            human_detection_confidence: DayNightConfig;
            motion_zone_overlap: DayNightConfig;
            object_size_maximum: DayNightConfig;
            object_size_minimum: DayNightConfig;
            object_time_overlap: DayNightConfig;
        };
    };
    chime_settings: {
        duration: number;
        enable: boolean;
        enable_ext: boolean;
        type: number;
    };
    motion_settings: {
        enable_audio: boolean;
        motion_detection_enabled: boolean;
        enable_ir_led: boolean;
        advanced_motion_detection_enabled: boolean;
        advanced_motion_detection_mode: string;
        advanced_motion_detection_human_only_mode: boolean;
        advanced_motion_detection_loitering_mode: boolean;
        motion_snooze_privacy_timeout: number;
        advanced_motion_zones_enabled: boolean;
        advanced_motion_zones_type: string;
        enable_indoor_mode: boolean;
        enable_pir_validation: boolean;
        loitering_threshold: number;
        enable_rlmd: boolean;
        enable_recording: boolean;
        end_detection: number;
        advanced_motion_recording_human_mode: boolean;
        advanced_motion_glance_enabled: boolean;
    };
    video_settings: {
        exposure_control: number;
        night_color_enable: boolean;
        hdr_enable: boolean;
        clip_length_max: number;
        clip_length_min: number;
        ae_mode: number;
        ae_mask: string;
    };
    vod_settings: {
        enable: boolean;
        toggled_at: string;
        use_cached_vod_domain: boolean;
    };
    volume_settings: {
        doorbell_volume: number;
        mic_volume: number;
        voice_volume: number;
    };
    cv_settings: {
        detection_types: {
            human: CvDetectionType;
            loitering: CvDetectionType;
            motion: CvDetectionType;
            moving_vehicle: CvDetectionType;
            nearby_pom: CvDetectionType;
            other_motion: CvDetectionType;
            package_delivery: CvDetectionType;
            package_pickup: CvDetectionType;
        };
        threshold: {
            loitering: number;
            package_delivery: number;
        };
    };
    general_settings: {
        enable_audio_recording: boolean;
        lite_24x7_enabled: boolean;
        offline_motion_event_enabled: boolean;
        lite_24x7_subscribed: boolean;
        offline_motion_event_subscribed: boolean;
        firmwares_locked: boolean;
        utc_offset: string;
        theft_alarm_enable: boolean;
        use_wrapup_domain: boolean;
        power_mode: 'battery' | 'wired';
        data_collection_enabled: boolean;
    };
    keep_alive_settings: {
        keep_alive_auto: number;
    };
    pir_settings: {
        sensitivity_1: number;
        sensitivity_2: number;
        sensitivity_3: number;
        zone_enable: number;
    };
    snapshot_settings: {
        frequency_secs: number;
        lite_24x7_resolution_p: number;
        ome_resolution_p: number;
        max_upload_kb: number;
        frequency_after_secs: number;
        period_after_secs: number;
        close_container: number;
    };
    client_device_settings: {
        ringtones_enabled: boolean;
        people_only_enabled: boolean;
        advanced_motion_enabled: boolean;
        motion_message_enabled: boolean;
        shadow_correction_enabled: boolean;
        night_vision_enabled: boolean;
        light_schedule_enabled: boolean;
        rich_notifications_eligible: boolean;
        show_24x7_lite: boolean;
        show_offline_motion_events: boolean;
        cfes_eligible: boolean;
        show_radar_data: boolean;
        motion_zone_recommendation: boolean;
    };
    concierge_settings?: {
        alexa_settings?: {
            delay_ms: number;
        };
        autoreply_settings?: {
            delay_ms: number;
        };
        mode?: string;
    };
}
type HealthCategory = 'very_poor' | 'poor' | 'good' | 'very_good' | 'unknown' | 'NA' | string | null;
export interface ChimeHealth {
    id: number;
    wifi_name: string;
    battery_percentage: HealthCategory;
    battery_percentage_category: HealthCategory;
    battery_voltage: number | null;
    battery_voltage_category: HealthCategory;
    latest_signal_strength: number;
    latest_signal_category: HealthCategory;
    average_signal_strength: number;
    average_signal_category: HealthCategory;
    firmware: Firmware;
    updated_at: 'string';
    wifi_is_ring_network: boolean;
    packet_loss_category: HealthCategory;
    packet_loss_strength: number;
}
export interface CameraHealth extends ChimeHealth {
    transformer_voltage?: number;
    transformer_voltage_category?: 'good';
    ext_power_state?: number;
}
export type DingKind = 'motion' | 'ding' | 'on_demand' | 'alarm' | 'on_demand_link' | 'door_activity' | 'key_access' | 'DELETED_FOOTAGE' | 'OFFLINE_FOOTAGE' | 'OFFLINE_MOTION';
export interface CameraEvent {
    created_at: string;
    cv_properties: {
        detection_type: null | any;
        person_detected: null | any;
        stream_broken: null | any;
    };
    ding_id: number;
    ding_id_str: string;
    doorbot_id: number;
    favorite: boolean;
    kind: DingKind;
    recorded: false;
    recording_status: 'ready' | 'audio_ready';
    state: 'timed_out' | 'completed';
}
export interface CameraEventResponse {
    events: CameraEvent[];
    meta: {
        pagination_key: string;
    };
}
export interface CameraEventOptions {
    limit?: number;
    kind?: DingKind;
    state?: 'missed' | 'accepted' | 'person_detected';
    favorites?: boolean;
    olderThanId?: string;
    pagination_key?: string;
}
export interface VideoSearchResult {
    ding_id: string;
    created_at: number;
    hq_url: null | string;
    lq_url: string;
    preroll_duration: null | unknown;
    thumbnail_url: string;
    untranscoded_url: string;
    kind: DingKind;
    state: 'timed_out' | 'completed';
    had_subscription: boolean;
    favorite: boolean;
    duration: number;
    cv_properties: {
        person_detected: null | unknown;
        stream_broken: null | unknown;
        detection_type: null | unknown;
    };
}
export interface VideoSearchResponse {
    video_search: VideoSearchResult[];
}
export interface PeriodicalFootage {
    start_ms: number;
    end_ms: number;
    playback_ms: number;
    kind: 'online_periodical' | 'offline_periodical';
    url: string;
    deleted: boolean;
    snapshots: number[];
}
export interface PeriodicFootageResponse {
    meta: {
        pagination_key: number;
        butch_size: number;
    };
    data: PeriodicalFootage[];
    responseTimestamp: number;
}
export interface HistoryOptions {
    limit?: number;
    offset?: number;
    category?: 'alarm' | 'beams';
    maxLevel?: number;
}
export interface RingDeviceHistoryEvent {
    msg: 'DataUpdate';
    datatype: MessageDataType;
    body: any;
}
export type DingState = 'ringing' | 'connected' | 'timed_out' | 'completed';
export declare const NotificationDetectionType: {
    readonly Human: "human";
    readonly Loitering: "loitering";
    readonly Motion: "motion";
    readonly OtherMotion: "other_motion";
    readonly NotAvailable: "null";
    readonly StreamBroken: "stream_broken";
};
export type NotificationDetectionType = (typeof NotificationDetectionType)[keyof typeof NotificationDetectionType];
export declare const PushNotificationAction: {
    readonly Ding: "com.ring.pn.live-event.ding";
    readonly Motion: "com.ring.pn.live-event.motion";
    readonly IntercomDing: "com.ring.pn.live-event.intercom";
    readonly IntercomUnlock: "com.ring.push.INTERCOM_UNLOCK_FROM_APP";
    readonly AlarmModeNone: "com.ring.push.HANDLE_NEW_SECURITY_PANEL_MODE_NONE_NOTICE";
    readonly AlarmModeSome: "com.ring.push.HANDLE_NEW_SECURITY_PANEL_MODE_SOME_NOTICE";
    readonly AlarmSoundSiren: "com.ring.push.HANDLE_NEW_USER_SOUND_SIREN";
    readonly AlarmSilenceSiren: "com.ring.push.HANDLE_NEW_NON_ALARM_SIREN_SILENCED";
};
export type PushNotificationAction = (typeof PushNotificationAction)[keyof typeof PushNotificationAction];
export interface PushNotificationDingV2 {
    version: '2.0.0' | string;
    android_config: {
        category: PushNotificationAction | string;
        body: string;
    };
    analytics: {
        server_correlation_id: string;
        server_id: 'com.ring.pns' | string;
        subcategory: string;
        triggered_at: number;
        sent_at: number;
        referring_item_type: string;
        referring_item_id: string;
    };
    data: {
        device: {
            e2ee_enabled: boolean;
            id: number;
            kind: RingCameraKind | typeof RingDeviceType.IntercomHandsetAudio;
            name: string;
        };
        event: {
            ding: {
                id: string;
                created_at: string;
                subtype: 'other_motion' | 'motion' | 'ding' | 'human' | string;
                detection_type?: NotificationDetectionType;
            };
            eventito: {
                type: NotificationDetectionType;
                timestamp: number;
            };
            riid: string;
            is_sidewalk: boolean;
            live_session: {
                streaming_data_hash: string;
                active_streaming_profile: 'rms' | string;
                default_audio_route: string;
                max_duration: number;
            };
        };
        location: {
            id: string;
        };
    };
    img?: {
        snapshot_uuid: string;
    };
}
interface PushNotificationAlarm {
    aps: {
        alert: string;
    };
    action: PushNotificationAction | string;
    alarm_meta: {
        device_zid: number;
        location_id: string;
    };
}
export interface PushNotificationAlarmV2 {
    data: {
        gcmData: PushNotificationAlarm;
    };
}
interface PushNotificationIntercomUnlock {
    aps: {
        alert: string;
    };
    action: typeof PushNotificationAction.IntercomUnlock;
    alarm_meta: {
        device_zid: number;
        location_id: string;
    };
}
export interface PushNotificationIntercomUnlockV2 {
    data: {
        gcmData: PushNotificationIntercomUnlock;
    };
}
export type PushNotification = PushNotificationDingV2 | PushNotificationAlarmV2 | PushNotificationIntercomUnlockV2;
export interface SocketTicketResponse {
    ticket: string;
    responseTimestampe: number;
}
export interface AuthTokenResponse {
    access_token: string;
    expires_in: number;
    refresh_token: string;
    scope: 'client';
    token_type: 'Bearer';
}
export type TwoStageVerificationState = 'sms' | 'email' | 'totp';
export type Auth2faResponse = {
    error?: string | unknown;
    error_description?: string;
} | {
    next_time_in_secs: number;
    phone: string;
    tsv_state: TwoStageVerificationState;
};
export interface ProfileResponse {
    profile: {
        id: number;
        email: string;
        first_name: string;
        last_name: string;
        phone_number: string;
        authentication_token: string;
        features: {
            [name: string]: boolean | number | string | string[];
        };
        user_preferences: {
            settings: any;
            preferences: any;
        };
        hardware_id: string;
        explorer_program_terms: null;
        user_flow: 'ring' | string;
        app_brand: string;
        country: string;
        status: 'legacy' | string;
        created_at: string;
        tfa_enabled: boolean;
        tfa_phone_number: null | string;
        account_type: 'ring' | string;
    };
}
export type SessionResponse = ProfileResponse;
export interface AccountMonitoringStatus {
    accountUuid: string;
    externalServiceConfigType: 'rrms' | string;
    accountState: 'PROFESSIONAL' | string;
    eligibleForDispatch: boolean;
    addressComplete: boolean;
    contactsComplete: boolean;
    codewordComplete: boolean;
    alarmSignalSent: boolean;
    professionallyMonitored: boolean;
    userAcceptDispatch: boolean;
    installationDate: number;
    externalId: string;
    vrRequired: false;
    vrUserOptIn: false;
    cmsMonitoringType: 'full' | string;
    dispatchSetupComplete: boolean;
}
export declare const DispatchSignalType: {
    readonly Burglar: "user-verified-burglar-xa";
    readonly Fire: "user-verified-fire-xa";
};
export type DispatchSignalType = (typeof DispatchSignalType)[keyof typeof DispatchSignalType];
export type LocationModeInput = 'home' | 'away' | 'disarmed';
export type LocationMode = LocationModeInput | 'disabled' | 'unset';
export declare const disabledLocationModes: LocationMode[];
export interface LocationModeResponse {
    mode: LocationMode;
    lastUpdateTimeMS: number;
    securityStatus: {
        lu?: number;
        md: 'none' | string;
        returnTopic: string;
    };
    readOnly: boolean;
    notYetParticipatingInMode?: {
        deviceId: number;
        deviceIdType: 'doorbot' | string;
    }[];
}
export type LocationModeAction = 'disableMotionDetection' | 'enableMotionDetection' | 'blockLiveViewLocally' | 'allowLiveViewLocally';
export interface LocationModeSetting {
    deviceId: string;
    deviceIdType: 'doorbot' | string;
    actions: LocationModeAction[];
}
export interface LocationModeSettings {
    disarmed: LocationModeSetting[];
    home: LocationModeSetting[];
    away: LocationModeSetting[];
}
export interface LocationModeSettingsResponse extends LocationModeSettings {
    lastUpdateTimeMS: number;
}
export interface LocationModeSharing {
    sharedUsersEnabled: boolean;
    lastUpdateTimeMS: number;
}
export declare function isWebSocketSupportedAsset({ kind }: {
    kind: AssetKind;
}): boolean;
export {};