Command and status enums, each tied to a wire byte. Conversion helpers are listed with each.

enum DeviceKind { Unknown, Keyboard, Mouse }

The kind field of a DeviceInfo, read from the cloned device's USB Boot-interface bInterfaceProtocol. It also drives find_mouse_box and find_keyboard_box. Display prints the lowercase name.

enum Button { Left, Right, Middle, Side1, Side2 }

The button an INJECT command acts on. A Button converts Into<Usage> as class button, so you pass one straight to inject. Convert with as_id() -> u8 and from_id(u8) -> Option<Button>.

enum Action { SoftRelease, Press, ForceRelease }

The shared override action for an inject call, on any Usage class (button, key, or media). The discriminant is the wire byte. Convert with as_u8() and from_u8(u8) -> Option<Action>.

The two releases differ only when the user physically holds the same input:

enum Class { Button, Key, Media }

The class byte of a Usage, shared by INJECT, LOCK, and CATCH. Convert with as_u8() and from_u8(u8) -> Option<Class>.

enum CatchClass { Button, Key, Media, Axis, HidIn, HidOut, VendorInterrupt, VendorBulk, Control, Emit, Bus }

The address space a CatchFilter picks from, and the class of a TrafficEvent. Convert with as_u8() and from_u8(u8) -> Option<CatchClass>; split it with is_input() and is_traffic().

The first four are LOCK's own classes at the same byte values. The other seven address USB traffic and have no lock counterpart; TrafficClass is that half on its own.

A blanket is one table entry, not an expansion into one per id. The wire sentinels never appear in Rust: CatchFilter::watch_class(c) and traffic_class(c) are the per-class blankets, and CatchFilter::everything() is the wildcard over all eleven, not a CatchClass variant.

The input classes are captured at the emission merge point, before lock suppression and injection, so a locked input still reports. Emit is the far end of the same path: what the clone actually put on the wire.

real device --> [ merge point ] --> locks --> injection --> [ clone emits ] --> game PC
                       |                                           |
          Button / Key / Media / Axis                            Emit

The traffic classes tap the pipes themselves, each on whichever chip owns that pipe. That split is what each event's ClockDomain records.

use medius::{Button, Capture, CatchFilter, Direction, TrafficClass};

// The same target, once as a lock and once as a catch.
device.lock(Button::Side1, Direction::Both)?;                    // suppressed in the emitted report
let stream = device.catch_events([
    CatchFilter::watch(Button::Side1).on_press(),                // the tap is before suppression
])?;

// A byte-oriented class instead: one vendor interrupt endpoint, IN only, 16 bytes a packet.
let trace = device.catch_events([
    CatchFilter::traffic(TrafficClass::VendorInterrupt, 0x83)
        .inbound()
        .with_capture(Capture::First(16)),
])?;

enum TrafficClass { HidIn, HidOut, VendorInterrupt, VendorBulk, Control, Emit, Bus }

The seven classes that carry packets, at the same byte values as their CatchClass counterparts. A separate enum so CatchFilter::traffic cannot be handed an input class. TrafficClass::ALL lists them; From and TryFrom convert both ways.

enum Capture { Whole, First(u8) }

Traffic classes only. An input class carries no packet, so naming one together with a capture is refused rather than ignored.

A ceiling request, not a guarantee: the box holds one entry per address and cuts once, so another subscriber naming the same address more widely raises yours too. First(0) is Whole; bytes() returns Option<u8> and widest() resolves two.

enum Input { Press(Usage), Release(Usage), Motion { dx: i16, dy: i16, dz: i16 } }

What input_events yields, wrapped in an InputEvent with its timestamp. usage(), is_press(), is_release(), direction() and axes() read it without a match.

struct Usage { class: Class, id: u16 }

What inject drives and LockTarget locks. A Button, Key, and MediaKey each impl Into<Usage>, so you pass one straight to any verb; build one by hand with Usage::new(class, id).

use medius::{Button, Class, Key, Usage};

let from_button: Usage = Button::Left.into();      // Class::Button, id 0
let from_key: Usage = Key::A.into();               // Class::Key, id 0x04
let by_hand = Usage::new(Class::Media, 0x00E9);    // volume up
device.press(from_button)?;                         // press takes any impl Into<Usage>

enum Motion { Cursor { dx: i16, dy: i16 }, Wheel(i16) }

What move_axis drives. Both span the full i16 range. A lock names a single Axis instead.

enum MoveTiming { Ride, Now }

The move_axis timing argument, against movement riding. Defaults to Ride.

enum PendingMotion { Keep, Flush, Discard }

The move_axis pending argument: what happens to motion the box is already holding for a real move. Defaults to Keep.

enum Axis { X, Y, Wheel }

One relative axis. A lock_axis or a LockTarget::Axis names one, with the sign given by a Direction. Convert with as_u16().

enum RebootTarget { DeviceDownload, HostDownload, DeviceRun, HostRun }

Which chip a REBOOT restarts, and into what mode. Convert with as_u8() and from_u8(u8) -> Option<RebootTarget>.

enum EmitPace { Learned, Interval, Fixed(u16) }

What sets the emit-rate ceiling for injected motion, passed to set_emit_pace and returned in EmitPaceStatus. It raises the ceiling only, so idle stays idle.

enum LedTarget { Device, Host, Both }

Which chip's LED a LED command drives. The discriminant is the wire target byte. Convert with as_u8() and from_u8(u8) -> Option<LedTarget>.

enum LedMode { Auto, Off, Solid, Blink }

What a LED command drives the LED to; Auto restores the box's status display. The discriminant is the wire mode byte. Convert with as_u8() and from_u8(u8) -> Option<LedMode>.

enum LockTarget { Axis(Axis), Usage(Usage) }

What a LOCK command blocks. An Axis and any impl Into<Usage> each convert Into<LockTarget>, so you pass one straight to lock. A button locks exactly like a key.

enum LockScope { Target(LockTarget), Blanket(Class) }

What a LockEntry in a query_locks reply covers.

enum Direction { Both, Positive, Negative, With, Against }

The one byte LOCK, CLIP and CATCH all carry. The variants are named for the axis reading; which of the three applies is decided by the class, and no class carries two. Convert with as_u8() and from_u8(u8) -> Option<Direction>.

A media usage has no edges. An edge named on one goes out as Both, which is what query_locks reports it as.

With and Against are measured against the bearing rather than a fixed sign, so the sign they cover follows the injection; is_relative() tells them apart, and a lock or catch call on any class but an axis refuses one with Error::RelativeDirection. See set_bearing.

The other two readings get their own names: Direction::PRESS and RELEASE for a usage, Direction::IN and OUT for traffic. admits() tests one against another, and of_delta() reads the sign of a movement.

enum BearingMode { PerAxis, Vector }

What set_bearing chooses, and what Direction::With and Against are resolved by. Convert with as_u8() and from_u8(u8) -> Option<BearingMode>.

In Vector the relative pair addresses X and Y as one vector: the box takes the lower of X's and Y's scale and applies it to both axes, so address them together with scale_all. What Locks reports back is there.

The projection is the first of two stages. Each axis's Positive / Negative scale then applies to what the projection left on that axis, so it can weigh motion the projection moved there. See set_bearing.

enum Blanket { Aim, Wheel, Buttons, Keys, Media }

A whole input group: which one scale_all / lock_all weigh in one call, and the members of a clip's ClipSettings auto-lock.

enum LogLevel { Error, Warn, Info, Debug, Verbose }

The severity tag on a LogLine. from_u8(u8) is infallible: an unknown byte falls back to Info.

enum CatchEvent { Motion(MotionEvent), Usages(UsageSnapshot), Traffic(TrafficEvent) }

What an EventStream yields, one variant per event frame the box pushes.

All three carry ts_us and a ClockDomain: a stamp compares only to another from the same domain, until you apply the ClockEstimate.

One rolling seq counter covers all three frame types. It counts what the box sent, not what it saw, so a gap is not how you detect loss. CatchState is.

use medius::{CatchEvent, CatchFilter};

let stream = device.catch_events([CatchFilter::everything()])?;
match stream.recv()? {
    CatchEvent::Motion(m)  => println!("{} {} {}", m.dx, m.dy, m.dz),
    CatchEvent::Usages(s)  => println!("{} held", s.usages.len()),
    CatchEvent::Traffic(t) => println!("{:?} 0x{:04X}: {} bytes", t.class, t.id, t.true_len),
}

enum ClockDomain { HostChip, DeviceChip }

The clock field beside every event's ts_us. The box runs two microsecond timers and nothing relates them; stamping happens on whichever chip saw the event. Convert with as_u8() and from_u8(u8) -> Option<ClockDomain>.

Both timers are box-local, unrelated to any clock on this machine. They wrap every ~71.6 minutes (a u32 of microseconds) and restart at zero when their chip reboots.

A stamp below the one before it is a wrap, a reboot, or a domain change, and only the third is visible in the value itself. To put both domains on one timeline, apply the ClockEstimate from query_catch.

enum ControlStatus { Ok, Stalled, Naked, Other(u8) }

Read it with TrafficEvent::control_status(), which returns None for any class other than Control.

enum BusEvent { Reset, Suspend, Resume, Configured(u8), Deconfigured,
                SetInterface { interface: u8, alt: u8 },
                DeviceAttached, DeviceDetached, CloneUp, CloneDown }

The kind of a CatchClass::Bus event. Read it with TrafficEvent::bus_event(), which returns Option<BusEvent>, which is None for a kind byte with no variant in this build. The two kinds that carry operands parse them into their own fields.

DeviceAttached and DeviceDetached are the real device on USB3; the other eight are the clone's own USB1 bus, which the control PC is not on.

use medius::{BusEvent, CatchEvent, CatchFilter, TrafficClass};

let stream = device.catch_events([CatchFilter::traffic_class(TrafficClass::Bus)])?;
if let CatchEvent::Traffic(t) = stream.recv()? {
    match t.bus_event() {
        Some(BusEvent::Configured(n))              => println!("configuration {n}"),
        Some(BusEvent::SetInterface { interface, alt }) => println!("iface {interface} alt {alt}"),
        Some(kind)                                 => println!("{kind:?}"),
        None                                       => {}
    }
}

enum ClipState { Idle, Playing, Paused, Faulted }

The device-side clip state on ClipStatus::state, from ClipHandle::query_status().

enum Edge { Both, Press, Release }

Which edge of a bound usage fires a ClipTrigger: its press, its release, or either. It shares wire values with Direction.

enum ClipAction { Start, Stop, Pause, Resume, Restart, Toggle }

What a bound ClipTrigger does to the clip when its edge fires. The discriminant doubles as the CLIP_CTRL op byte for the same action.

The bootloader's own record for a slot. See rollback.