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>.

struct Usage { class: Class, id: u16 }

What inject drives and LockTarget locks: a mouse button, a keyboard key, or a media usage in one shape. 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: the cursor (carrying dx and dy) or the wheel (a single delta). Both span the full i16 range. A lock names a single Axis instead.

enum Axis { X, Y, Wheel }

One relative axis, the input kind that is genuinely mouse-hardware-specific. A lock_axis or a LockTarget::Axis names one, with the sign given by a LockDirection. 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 hands it back to 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: a relative Axis or a momentary Usage (a button, key, or media usage). 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: one specific LockTarget, or a whole-class blanket that locks every usage of a Class at once.

enum LockDirection { Both, Positive, Negative }

Which side of an input a LOCK blocks. For an axis or the wheel it's a sign; for a usage (button, key, or media) it's an edge. The discriminant is the wire direction byte. Convert with as_u8() and from_u8(u8) -> Option<LockDirection>.

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

A whole input group: which one lock_all / unlock_all block 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) }

What an EventStream yields, captured before lock suppression or injection. A relative axis is Motion; a held-usage snapshot (buttons, keys, or media, all one shape) is Usages. Match on the variant.

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 LockDirection.

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.