Borrow the underlying transport (e.g. to disconnect a BLE link).

Update with a new (unscaled) sample given the baseline age in days. The step size anneals across three age bands (<4, 4–14, >14 days): the warm-up is

Encode to wire bytes: `[tag, len, payload..]`.

Authenticate if a key was supplied; returns whether auth was performed.

Disconnect from the ring.

The extended op tag (first payload byte) for `0x2f` frames.

Clear the RData session/data from the ring's flash (part of teardown). Returns the response status byte (255 if absent).

Query the RData collection state (read-only). Returns `(subtag, status)`.

Scan for and connect to a ring, selecting the strongest match for `name_contains`. If `address` is given, only a device whose id matches is considered

Stop an active RData collection session (part of mandatory teardown). Returns the response status byte (255 if absent).

Resolve the SQLite events DB path. Explicit ``arg`` wins; otherwise pick the first existing default among ./oura.db, repo/oura.db, repo/captu

Read the ring serial number.

Align the ring clock to host UTC.

Arithmetic shift right with round-toward-zero bias, matching the decompiled `(t < 0) ? (t + (2^s - 1)) >> s : t >> s`.

Read battery state (requires app-auth on rings with a key installed).

Identify a BLE/radio-telemetry or diagnostic event whose payload layout is device-internal: tag the event by name and preserve the raw body (plus the

Record a scalar reading (e.g. live HR bpm, SpO2 %, battery %).

2-D float32 tensor from row-major `rows` of `cols` each (handles empty).

Mean in real units.

Configure/arm an RData session for one or more signal types. **This starts persistent flash sampling that does NOT self-stop** — the caller is respons

Set a feature's mode (e.g. `feature_mode::AUTOMATIC` to enable measurement).

Run the app-auth challenge with a 16-byte key. Must be repeated per connection on rings that have a key installed.

`debug_data` (tag `0x61`): ASCII when the body is printable, otherwise a binary DebugData record dispatched on the first byte (subtype). Charging/batt

Decode a body of one or more little-endian `i16` temperatures in centi-degrees Celsius. Returns `None` if the length is odd or any value falls outside

Read firmware/version metadata (no auth required).

Case-insensitive lookup of an HTTP header value in the raw request.

Register canned responses keyed by the request's full hex.

Parse an ACM measurement indication (response tag `0x33`) into up to 2 samples. Frame: `[0]=0x33 [1]=len [2]=sampleRate [3]=seq [4..10]=x,y,z [10..16

Stop all real-time measurements (`06 04 00000000`, bitmask 0 = off).

Set a feature's mode (`0x2f` ext `0x22`).

Serve the visualizer at `127.0.0.1:port` (see [`crate::motion_server::run`]).

Persist the next sync cursor.

Subscribe/unsubscribe a feature capability (e.g. real steps, Atlas/bioZ) via `SetFeatureSubscription`. Returns the ring's raw result byte (0 = success

Compute bpm from an inter-beat interval, ignoring implausible values.

Read both capability pages.

Days-since-epoch -> (year, month, day). Howard Hinnant's civil_from_days.

`activity_information`: a state byte followed by per-bin MET levels. The native `parse_api_activity_info_event` scales each byte `b<128 -> b*0.1`, els

`ambient_event` (tag `0x84`): signed-16 samples at a 5-minute interval.

`aohr_event` (tag `0x86`): always-on HR. Header flag, a base offset, then a count and `count` 2-byte samples `(value, status)` at a fixed 1920 ms inte

`atlas_raw_bioz_data` (tag `0x88`): delta-coded i32 sample stream. Each byte is a signed-8 delta added to a running value; a `0x80` byte escapes into

`bedtime_period` (tag `0x76`): the ring's detected sleep window as two `u32` little-endian ring timestamps (deciseconds). Produced by sleep analysis.

Best-effort decode of an event body. Unknown bodies are intentionally left raw (see module docs). Returns `None` when we don't (yet) understand the la

`cva_raw_ppg_data` (tag 0x81): raw PPG ADC samples, delta-encoded as signed int8. Cumulative-sum reconstructs the waveform (per-event, relative to thi

`feature_session` (tag `0x6c`): start/stop markers for an on-ring measurement feature. `feature_id` (byte 0, < 8), `session_status` (byte 1, 0-12), an

`green_ibi_quality_event` (Ring 5 tag `0x80`): green-LED inter-beat intervals with a quality flag. Per the native `parse_api_green_ibi_quality_event`,

Decode an `hrv_event` body: pairs of `(avg_hr_bpm, avg_rmssd_ms)`, one sample per 5-minute window. Layout confirmed from the ring's native parser (`pa

`motion_event` (tag `0x47`): a compact per-window motion summary. From the native `parse_api_motion_events`: `b0>>5` = orientation, `b0&0x1f` = motion

Map an event tag to its name. Mirrors the Android app's event taxonomy. `motion_period` (tag `0x6b`): a compact activity timeline. The header byte pac

`sleep_acm_period` (tag `0x72`): six accelerometer MAD statistics packed as fixed-point — three `int + frac/255` values, then three `12-bit/4095 + nib

Sleep-stage hypnogram: a header byte then 2-bit phase codes (4 per byte, MSB-first). Enum from the native `SleepPhase_OSSAv1`.

`spo2_r_pi_event` (Ring 5 tag `0x8b`): a header byte then 3-byte samples of `(R-ratio: u16 big-endian / 16384, perfusion index: u8/255 × 0.05)`. The R

A body of little-endian `u16` samples under a single key (ambient, intensity).

Encrypt a ring nonce (typically 15 bytes) into the 16-byte response block. Mirrors the Android app's `AES/ECB/PKCS5Padding`: the nonce is PKCS7-padde

Count stored events grouped by event name (descending).

Read a feature's status (mode/state/subscription).

Most recent bedtime_period dict, or a clear error if none were synced.

Open (creating if needed) a database at `path` and ensure the schema.

Parse a daytime-HR live subscription notification (tag `0x2f`, sub-tag `0x28`). Frame layout: `[0]=0x2f [1]=len [2]=0x28(IND1) [3]=cap [4]=status [5]

Fetch one RData page by index. Returns `(status, page_bytes)` where `status` is the subtag-status byte (`6` = NO_DATA / past the end) and `page_bytes`

Start a time-boxed real-time measurement stream (`0x06`): a `u32` type bitmask (see [`realtime`]), a `u16` max duration in **minutes** (the ring auto-