Plain value types you get back from queries and discovery. Their fields are public.

Firmware identity from query_version(). Display prints fw M.m.p and omits proto_ver; read it from the field.

use medius::Version;

let v = Version { proto_ver: 3, fw_major: 3, fw_minor: 0, fw_patch: 0, mac: [0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc], name: "Loki".into() };
assert_eq!(v.to_string(), "fw 3.0.0"); // Display omits proto_ver
assert_eq!(v.mac_hex(), "123456789abc");
println!("{v} (protocol {}, box {}, name {})", v.proto_ver, v.mac_hex(), v.name);

Box readiness from query_health(), one bool per bit. from_flags(u8) and to_flags() convert the byte.

use medius::Health;

let h = Health::from_flags(0b0000_0011); // link_up | mouse_attached
assert!(h.link_up && h.mouse_attached);
assert!(!h.clone_configured);
assert_eq!(h.to_flags(), 0b0000_0011); // round-trips to the same byte

USB identity from device_info(). Every field is zero/empty when nothing is cloned. Display prints VVVV:PPPP product.

use medius::{DeviceInfo, DeviceKind};

let d = DeviceInfo {
    vid: 0x046D, pid: 0xC08B, bcd_device: 0, bcd_usb: 0x0201,
    has_serial: true, has_bos: true, kind: DeviceKind::Mouse, product: "G502".into(),
};
assert_eq!(d.to_string(), "046D:C08B G502"); // Display is VVVV:PPPP product

One caps() query, returned as one struct: a MouseCaps half and a KbdCaps half, plus the per-class change-driven flags. has_mouse() / has_keyboard() tell you which are bound; is_composite() is true when the device has more than one HID interface.

let caps = device.caps()?;
if caps.has_keyboard() && caps.keyboard.has_consumer {
    // media injection is real on this board
}
println!("{} mouse buttons", caps.mouse.n_buttons);

Semantic capabilities from caps(). Every field is zero when no relative-axis mouse interface is bound. is_composite() is true when n_hid > 1.

use medius::MouseCaps;

let c = MouseCaps { n_buttons: 5, has_x: true, has_y: true, has_wheel: true, has_report_id: false, n_hid: 1 };
assert!(!c.is_composite()); // single HID interface

Live rate from query_rate(). native_hz() converts the period to a frequency, returning None while native_period_us is still 0. The rate is class-aware: a change-driven input (a keyboard or media device) has no continuous cadence, so it sets change_driven and leaves native_period_us at 0, with poll_period_us the honest figure.

use medius::Rate;

let r = Rate { native_period_us: 1000, poll_period_us: 1000, confident: true, change_driven: false };
assert_eq!(r.native_hz(), Some(1000.0));

Delivery counters from query_stats(). A nonzero tx_drops or tx_wedges means delivery degraded under load. The narrowed fields saturate instead of wrapping.

Active locks from query_locks(), a list of LockEntry across every class, so mouse, key, and media locks read the same way. is_locked(target, dir) tests one lock; entries() is the whole list. See the native LOCKS reply for the wire format.

use medius::{Axis, Button, LockDirection};

let locks = device.query_locks()?;
if locks.is_locked(Axis::X, LockDirection::Positive) {
    // the real mouse can't move right
}
if locks.is_locked(Button::Left, LockDirection::Negative) {
    // a left-click is latched down: the hand can't release it
}
println!("{} locks active", locks.entries().len());

struct LockEntry { scope: LockScope, positive: bool, negative: bool }

One active lock in a Locks list: what is locked (its LockScope) and which edges.

A bitflags newtype you hand to catch_events(). It gates which reports raise a CatchEvent; the payload is always the full snapshot. Combine the consts with | (BitOr), e.g. CatchMask::MOTION | CatchMask::BUTTONS.

use medius::CatchMask;

let mask = CatchMask::MOTION | CatchMask::BUTTONS;
assert!(mask.contains(CatchMask::BUTTONS));
assert_eq!(mask.bits(), 0x05);
let stream = device.catch_events(mask)?;

The payload of a CatchEvent::Motion, read off an EventStream. The real hand motion at the merge point, before lock suppression or injection, so a locked or injected axis still reports the true delta.

use medius::{CatchMask, CatchEvent};

let stream = device.catch_events(CatchMask::MOTION | CatchMask::WHEEL)?;
if let CatchEvent::Motion(m) = stream.recv()? {
    println!("moved {} {}, wheel {}", m.dx, m.dy, m.dz);
}

The payload of a CatchEvent::Usages: every held Usage of one class (buttons, keys, or media, all one shape), captured before injection. Diff successive snapshots for press/release edges, or test one with is_held; a dropped frame self-corrects on the next.

use medius::{Button, CatchMask, CatchEvent};

let stream = device.catch_events(CatchMask::BUTTONS)?;
if let CatchEvent::Usages(s) = stream.recv()? {
    if s.is_held(Button::Left) {
        println!("left button held");
    }
}

A newtype over a HID keyboard/keypad usage. It converts Into<Usage>, so you pass one straight to inject or press. Named consts cover the common keys (Key::A, Key::ENTER, Key::LEFT_SHIFT); build any other with Key::new(u8). Modifiers are the usages 0xE0-0xE7.

use medius::Key;

let a = Key::A;            // 0x04
let custom = Key::new(0x04);
assert_eq!(a.usage(), custom.usage());

A newtype over a 16-bit Consumer usage. It converts Into<Usage>, so you pass one straight to inject or press. Named consts cover the common media keys (MediaKey::VOLUME_UP, MediaKey::PLAY_PAUSE, MediaKey::MUTE); build any other with MediaKey::new(u16).

use medius::MediaKey;

let vol_up = MediaKey::VOLUME_UP;   // 0x00E9
let custom = MediaKey::new(0xE9);
assert_eq!(vol_up.usage(), custom.usage());

Semantic capabilities from caps(). Every field is zero when no keyboard is bound. has_consumer gates media injection.

The current subscription from query_catch(). A nonzero dropped means the box shed events under back-pressure.

The imperfect-clone state from query_imperfect().

The emit-rate pacing state from query_emit_pace().

One line from the box's LOG stream, read off a LogStream.

A serial port that looks like a Medius box, from find_medius(). serial is the CH343 adapter's serial string, part of the box identity.

Four running link totals from counters().

Receives the box's LOG frames as LogLine values off a local channel, from device.logs(). Pull lines with recv / try_recv / recv_timeout / try_iter / recv_async (or for line in stream); none touch the wire, so cloning shares the queue. The methods and an example are on Logs & counters.

A clip's configuration from ClipHandle::query_config(): the auto-lock set, the loop and retain flags, whether it's finalized, and the bound ClipTrigger list. You set these with the handle setters (set_autolock, set_loop, set_retain, finalize, bind); this is the readback.

let cfg = handle.query_config()?;
if cfg.loop_ && cfg.finalized {
    println!("sealed looping clip, {} triggers", cfg.triggers.len());
}

One physical-input binding for a clip: on a given Usage and Edge, run a ClipAction. You hand these to ClipHandle::bind; the box keeps up to 8, keyed by usage and edge. consume hides the triggering input from the PC.

Build one with ClipTrigger::new(usage, edge, action) (consume defaults false), then chain .consume() to swallow the input:

fn new(on: impl Into<Usage>, edge: Edge, action: ClipAction) -> ClipTrigger

use medius::{Button, ClipAction, ClipTrigger, Edge};

// Toggle the clip on a Side1 press, and hide that press from the PC.
let trig = ClipTrigger::new(Button::Side1, Edge::Press, ClipAction::Toggle).consume();
handle.bind(trig)?;

The clip ring depth and playback counters from ClipHandle::query_status(). Pace top-ups off free; a ClipState::Faulted state means re-sync (stop, then rebuild).