steam-vent-proto 0.1.0

// This file is generated by rust-protobuf 2.24.1. Do not edit
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `steammessages_hiddevices.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_24_1;

#[derive(PartialEq,Clone,Default)]
pub struct CHIDDeviceInfo {
    // message fields
    location: ::std::option::Option<EHIDDeviceLocation>,
    path: ::protobuf::SingularField<::std::string::String>,
    vendor_id: ::std::option::Option<u32>,
    product_id: ::std::option::Option<u32>,
    serial_number: ::protobuf::SingularField<::std::string::String>,
    release_number: ::std::option::Option<u32>,
    manufacturer_string: ::protobuf::SingularField<::std::string::String>,
    product_string: ::protobuf::SingularField<::std::string::String>,
    usage_page: ::std::option::Option<u32>,
    usage: ::std::option::Option<u32>,
    interface_number: ::std::option::Option<i32>,
    ostype: ::std::option::Option<i32>,
    is_generic_gamepad: ::std::option::Option<bool>,
    is_generic_joystick: ::std::option::Option<bool>,
    caps_bits: ::std::option::Option<u32>,
    session_id: ::std::option::Option<u32>,
    eControllerType: ::std::option::Option<u32>,
    is_xinput_device: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDDeviceInfo {
    fn default() -> &'a CHIDDeviceInfo {
        <CHIDDeviceInfo as ::protobuf::Message>::default_instance()
    }
}

impl CHIDDeviceInfo {
    pub fn new() -> CHIDDeviceInfo {
        ::std::default::Default::default()
    }

    // optional .EHIDDeviceLocation location = 1;


    pub fn get_location(&self) -> EHIDDeviceLocation {
        self.location.unwrap_or(EHIDDeviceLocation::k_EDeviceLocationLocal)
    }
    pub fn clear_location(&mut self) {
        self.location = ::std::option::Option::None;
    }

    pub fn has_location(&self) -> bool {
        self.location.is_some()
    }

    // Param is passed by value, moved
    pub fn set_location(&mut self, v: EHIDDeviceLocation) {
        self.location = ::std::option::Option::Some(v);
    }

    // optional string path = 2;


    pub fn get_path(&self) -> &str {
        match self.path.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_path(&mut self) {
        self.path.clear();
    }

    pub fn has_path(&self) -> bool {
        self.path.is_some()
    }

    // Param is passed by value, moved
    pub fn set_path(&mut self, v: ::std::string::String) {
        self.path = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_path(&mut self) -> &mut ::std::string::String {
        if self.path.is_none() {
            self.path.set_default();
        }
        self.path.as_mut().unwrap()
    }

    // Take field
    pub fn take_path(&mut self) -> ::std::string::String {
        self.path.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional uint32 vendor_id = 3;


    pub fn get_vendor_id(&self) -> u32 {
        self.vendor_id.unwrap_or(0)
    }
    pub fn clear_vendor_id(&mut self) {
        self.vendor_id = ::std::option::Option::None;
    }

    pub fn has_vendor_id(&self) -> bool {
        self.vendor_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_vendor_id(&mut self, v: u32) {
        self.vendor_id = ::std::option::Option::Some(v);
    }

    // optional uint32 product_id = 4;


    pub fn get_product_id(&self) -> u32 {
        self.product_id.unwrap_or(0)
    }
    pub fn clear_product_id(&mut self) {
        self.product_id = ::std::option::Option::None;
    }

    pub fn has_product_id(&self) -> bool {
        self.product_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_product_id(&mut self, v: u32) {
        self.product_id = ::std::option::Option::Some(v);
    }

    // optional string serial_number = 5;


    pub fn get_serial_number(&self) -> &str {
        match self.serial_number.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_serial_number(&mut self) {
        self.serial_number.clear();
    }

    pub fn has_serial_number(&self) -> bool {
        self.serial_number.is_some()
    }

    // Param is passed by value, moved
    pub fn set_serial_number(&mut self, v: ::std::string::String) {
        self.serial_number = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_serial_number(&mut self) -> &mut ::std::string::String {
        if self.serial_number.is_none() {
            self.serial_number.set_default();
        }
        self.serial_number.as_mut().unwrap()
    }

    // Take field
    pub fn take_serial_number(&mut self) -> ::std::string::String {
        self.serial_number.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional uint32 release_number = 6;


    pub fn get_release_number(&self) -> u32 {
        self.release_number.unwrap_or(0)
    }
    pub fn clear_release_number(&mut self) {
        self.release_number = ::std::option::Option::None;
    }

    pub fn has_release_number(&self) -> bool {
        self.release_number.is_some()
    }

    // Param is passed by value, moved
    pub fn set_release_number(&mut self, v: u32) {
        self.release_number = ::std::option::Option::Some(v);
    }

    // optional string manufacturer_string = 7;


    pub fn get_manufacturer_string(&self) -> &str {
        match self.manufacturer_string.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_manufacturer_string(&mut self) {
        self.manufacturer_string.clear();
    }

    pub fn has_manufacturer_string(&self) -> bool {
        self.manufacturer_string.is_some()
    }

    // Param is passed by value, moved
    pub fn set_manufacturer_string(&mut self, v: ::std::string::String) {
        self.manufacturer_string = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_manufacturer_string(&mut self) -> &mut ::std::string::String {
        if self.manufacturer_string.is_none() {
            self.manufacturer_string.set_default();
        }
        self.manufacturer_string.as_mut().unwrap()
    }

    // Take field
    pub fn take_manufacturer_string(&mut self) -> ::std::string::String {
        self.manufacturer_string.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string product_string = 8;


    pub fn get_product_string(&self) -> &str {
        match self.product_string.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_product_string(&mut self) {
        self.product_string.clear();
    }

    pub fn has_product_string(&self) -> bool {
        self.product_string.is_some()
    }

    // Param is passed by value, moved
    pub fn set_product_string(&mut self, v: ::std::string::String) {
        self.product_string = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_product_string(&mut self) -> &mut ::std::string::String {
        if self.product_string.is_none() {
            self.product_string.set_default();
        }
        self.product_string.as_mut().unwrap()
    }

    // Take field
    pub fn take_product_string(&mut self) -> ::std::string::String {
        self.product_string.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional uint32 usage_page = 9;


    pub fn get_usage_page(&self) -> u32 {
        self.usage_page.unwrap_or(0)
    }
    pub fn clear_usage_page(&mut self) {
        self.usage_page = ::std::option::Option::None;
    }

    pub fn has_usage_page(&self) -> bool {
        self.usage_page.is_some()
    }

    // Param is passed by value, moved
    pub fn set_usage_page(&mut self, v: u32) {
        self.usage_page = ::std::option::Option::Some(v);
    }

    // optional uint32 usage = 10;


    pub fn get_usage(&self) -> u32 {
        self.usage.unwrap_or(0)
    }
    pub fn clear_usage(&mut self) {
        self.usage = ::std::option::Option::None;
    }

    pub fn has_usage(&self) -> bool {
        self.usage.is_some()
    }

    // Param is passed by value, moved
    pub fn set_usage(&mut self, v: u32) {
        self.usage = ::std::option::Option::Some(v);
    }

    // optional int32 interface_number = 11;


    pub fn get_interface_number(&self) -> i32 {
        self.interface_number.unwrap_or(-1i32)
    }
    pub fn clear_interface_number(&mut self) {
        self.interface_number = ::std::option::Option::None;
    }

    pub fn has_interface_number(&self) -> bool {
        self.interface_number.is_some()
    }

    // Param is passed by value, moved
    pub fn set_interface_number(&mut self, v: i32) {
        self.interface_number = ::std::option::Option::Some(v);
    }

    // optional int32 ostype = 12;


    pub fn get_ostype(&self) -> i32 {
        self.ostype.unwrap_or(-1i32)
    }
    pub fn clear_ostype(&mut self) {
        self.ostype = ::std::option::Option::None;
    }

    pub fn has_ostype(&self) -> bool {
        self.ostype.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ostype(&mut self, v: i32) {
        self.ostype = ::std::option::Option::Some(v);
    }

    // optional bool is_generic_gamepad = 13;


    pub fn get_is_generic_gamepad(&self) -> bool {
        self.is_generic_gamepad.unwrap_or(false)
    }
    pub fn clear_is_generic_gamepad(&mut self) {
        self.is_generic_gamepad = ::std::option::Option::None;
    }

    pub fn has_is_generic_gamepad(&self) -> bool {
        self.is_generic_gamepad.is_some()
    }

    // Param is passed by value, moved
    pub fn set_is_generic_gamepad(&mut self, v: bool) {
        self.is_generic_gamepad = ::std::option::Option::Some(v);
    }

    // optional bool is_generic_joystick = 14;


    pub fn get_is_generic_joystick(&self) -> bool {
        self.is_generic_joystick.unwrap_or(false)
    }
    pub fn clear_is_generic_joystick(&mut self) {
        self.is_generic_joystick = ::std::option::Option::None;
    }

    pub fn has_is_generic_joystick(&self) -> bool {
        self.is_generic_joystick.is_some()
    }

    // Param is passed by value, moved
    pub fn set_is_generic_joystick(&mut self, v: bool) {
        self.is_generic_joystick = ::std::option::Option::Some(v);
    }

    // optional uint32 caps_bits = 15;


    pub fn get_caps_bits(&self) -> u32 {
        self.caps_bits.unwrap_or(0)
    }
    pub fn clear_caps_bits(&mut self) {
        self.caps_bits = ::std::option::Option::None;
    }

    pub fn has_caps_bits(&self) -> bool {
        self.caps_bits.is_some()
    }

    // Param is passed by value, moved
    pub fn set_caps_bits(&mut self, v: u32) {
        self.caps_bits = ::std::option::Option::Some(v);
    }

    // optional uint32 session_id = 16;


    pub fn get_session_id(&self) -> u32 {
        self.session_id.unwrap_or(0)
    }
    pub fn clear_session_id(&mut self) {
        self.session_id = ::std::option::Option::None;
    }

    pub fn has_session_id(&self) -> bool {
        self.session_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_session_id(&mut self, v: u32) {
        self.session_id = ::std::option::Option::Some(v);
    }

    // optional uint32 eControllerType = 17;


    pub fn get_eControllerType(&self) -> u32 {
        self.eControllerType.unwrap_or(0u32)
    }
    pub fn clear_eControllerType(&mut self) {
        self.eControllerType = ::std::option::Option::None;
    }

    pub fn has_eControllerType(&self) -> bool {
        self.eControllerType.is_some()
    }

    // Param is passed by value, moved
    pub fn set_eControllerType(&mut self, v: u32) {
        self.eControllerType = ::std::option::Option::Some(v);
    }

    // optional bool is_xinput_device = 18;


    pub fn get_is_xinput_device(&self) -> bool {
        self.is_xinput_device.unwrap_or(false)
    }
    pub fn clear_is_xinput_device(&mut self) {
        self.is_xinput_device = ::std::option::Option::None;
    }

    pub fn has_is_xinput_device(&self) -> bool {
        self.is_xinput_device.is_some()
    }

    // Param is passed by value, moved
    pub fn set_is_xinput_device(&mut self, v: bool) {
        self.is_xinput_device = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CHIDDeviceInfo {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.location, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.path)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.vendor_id = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.product_id = ::std::option::Option::Some(tmp);
                },
                5 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.serial_number)?;
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.release_number = ::std::option::Option::Some(tmp);
                },
                7 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.manufacturer_string)?;
                },
                8 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.product_string)?;
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.usage_page = ::std::option::Option::Some(tmp);
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.usage = ::std::option::Option::Some(tmp);
                },
                11 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.interface_number = ::std::option::Option::Some(tmp);
                },
                12 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.ostype = ::std::option::Option::Some(tmp);
                },
                13 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_generic_gamepad = ::std::option::Option::Some(tmp);
                },
                14 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_generic_joystick = ::std::option::Option::Some(tmp);
                },
                15 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.caps_bits = ::std::option::Option::Some(tmp);
                },
                16 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.session_id = ::std::option::Option::Some(tmp);
                },
                17 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.eControllerType = ::std::option::Option::Some(tmp);
                },
                18 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_xinput_device = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.location {
            my_size += ::protobuf::rt::enum_size(1, v);
        }
        if let Some(ref v) = self.path.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.vendor_id {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.product_id {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.serial_number.as_ref() {
            my_size += ::protobuf::rt::string_size(5, &v);
        }
        if let Some(v) = self.release_number {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.manufacturer_string.as_ref() {
            my_size += ::protobuf::rt::string_size(7, &v);
        }
        if let Some(ref v) = self.product_string.as_ref() {
            my_size += ::protobuf::rt::string_size(8, &v);
        }
        if let Some(v) = self.usage_page {
            my_size += ::protobuf::rt::value_size(9, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.usage {
            my_size += ::protobuf::rt::value_size(10, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.interface_number {
            my_size += ::protobuf::rt::value_size(11, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.ostype {
            my_size += ::protobuf::rt::value_size(12, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.is_generic_gamepad {
            my_size += 2;
        }
        if let Some(v) = self.is_generic_joystick {
            my_size += 2;
        }
        if let Some(v) = self.caps_bits {
            my_size += ::protobuf::rt::value_size(15, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.session_id {
            my_size += ::protobuf::rt::value_size(16, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.eControllerType {
            my_size += ::protobuf::rt::value_size(17, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.is_xinput_device {
            my_size += 3;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.location {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&v))?;
        }
        if let Some(ref v) = self.path.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.vendor_id {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.product_id {
            os.write_uint32(4, v)?;
        }
        if let Some(ref v) = self.serial_number.as_ref() {
            os.write_string(5, &v)?;
        }
        if let Some(v) = self.release_number {
            os.write_uint32(6, v)?;
        }
        if let Some(ref v) = self.manufacturer_string.as_ref() {
            os.write_string(7, &v)?;
        }
        if let Some(ref v) = self.product_string.as_ref() {
            os.write_string(8, &v)?;
        }
        if let Some(v) = self.usage_page {
            os.write_uint32(9, v)?;
        }
        if let Some(v) = self.usage {
            os.write_uint32(10, v)?;
        }
        if let Some(v) = self.interface_number {
            os.write_int32(11, v)?;
        }
        if let Some(v) = self.ostype {
            os.write_int32(12, v)?;
        }
        if let Some(v) = self.is_generic_gamepad {
            os.write_bool(13, v)?;
        }
        if let Some(v) = self.is_generic_joystick {
            os.write_bool(14, v)?;
        }
        if let Some(v) = self.caps_bits {
            os.write_uint32(15, v)?;
        }
        if let Some(v) = self.session_id {
            os.write_uint32(16, v)?;
        }
        if let Some(v) = self.eControllerType {
            os.write_uint32(17, v)?;
        }
        if let Some(v) = self.is_xinput_device {
            os.write_bool(18, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDDeviceInfo {
        CHIDDeviceInfo::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EHIDDeviceLocation>>(
                "location",
                |m: &CHIDDeviceInfo| { &m.location },
                |m: &mut CHIDDeviceInfo| { &mut m.location },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "path",
                |m: &CHIDDeviceInfo| { &m.path },
                |m: &mut CHIDDeviceInfo| { &mut m.path },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "vendor_id",
                |m: &CHIDDeviceInfo| { &m.vendor_id },
                |m: &mut CHIDDeviceInfo| { &mut m.vendor_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "product_id",
                |m: &CHIDDeviceInfo| { &m.product_id },
                |m: &mut CHIDDeviceInfo| { &mut m.product_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "serial_number",
                |m: &CHIDDeviceInfo| { &m.serial_number },
                |m: &mut CHIDDeviceInfo| { &mut m.serial_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "release_number",
                |m: &CHIDDeviceInfo| { &m.release_number },
                |m: &mut CHIDDeviceInfo| { &mut m.release_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "manufacturer_string",
                |m: &CHIDDeviceInfo| { &m.manufacturer_string },
                |m: &mut CHIDDeviceInfo| { &mut m.manufacturer_string },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "product_string",
                |m: &CHIDDeviceInfo| { &m.product_string },
                |m: &mut CHIDDeviceInfo| { &mut m.product_string },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "usage_page",
                |m: &CHIDDeviceInfo| { &m.usage_page },
                |m: &mut CHIDDeviceInfo| { &mut m.usage_page },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "usage",
                |m: &CHIDDeviceInfo| { &m.usage },
                |m: &mut CHIDDeviceInfo| { &mut m.usage },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "interface_number",
                |m: &CHIDDeviceInfo| { &m.interface_number },
                |m: &mut CHIDDeviceInfo| { &mut m.interface_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "ostype",
                |m: &CHIDDeviceInfo| { &m.ostype },
                |m: &mut CHIDDeviceInfo| { &mut m.ostype },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_generic_gamepad",
                |m: &CHIDDeviceInfo| { &m.is_generic_gamepad },
                |m: &mut CHIDDeviceInfo| { &mut m.is_generic_gamepad },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_generic_joystick",
                |m: &CHIDDeviceInfo| { &m.is_generic_joystick },
                |m: &mut CHIDDeviceInfo| { &mut m.is_generic_joystick },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "caps_bits",
                |m: &CHIDDeviceInfo| { &m.caps_bits },
                |m: &mut CHIDDeviceInfo| { &mut m.caps_bits },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "session_id",
                |m: &CHIDDeviceInfo| { &m.session_id },
                |m: &mut CHIDDeviceInfo| { &mut m.session_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "eControllerType",
                |m: &CHIDDeviceInfo| { &m.eControllerType },
                |m: &mut CHIDDeviceInfo| { &mut m.eControllerType },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_xinput_device",
                |m: &CHIDDeviceInfo| { &m.is_xinput_device },
                |m: &mut CHIDDeviceInfo| { &mut m.is_xinput_device },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDDeviceInfo>(
                "CHIDDeviceInfo",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDDeviceInfo {
        static instance: ::protobuf::rt::LazyV2<CHIDDeviceInfo> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDDeviceInfo::new)
    }
}

impl ::protobuf::Clear for CHIDDeviceInfo {
    fn clear(&mut self) {
        self.location = ::std::option::Option::None;
        self.path.clear();
        self.vendor_id = ::std::option::Option::None;
        self.product_id = ::std::option::Option::None;
        self.serial_number.clear();
        self.release_number = ::std::option::Option::None;
        self.manufacturer_string.clear();
        self.product_string.clear();
        self.usage_page = ::std::option::Option::None;
        self.usage = ::std::option::Option::None;
        self.interface_number = ::std::option::Option::None;
        self.ostype = ::std::option::Option::None;
        self.is_generic_gamepad = ::std::option::Option::None;
        self.is_generic_joystick = ::std::option::Option::None;
        self.caps_bits = ::std::option::Option::None;
        self.session_id = ::std::option::Option::None;
        self.eControllerType = ::std::option::Option::None;
        self.is_xinput_device = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDDeviceInfo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDDeviceInfo {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDDeviceInputReport {
    // message fields
    full_report: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    delta_report: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    delta_report_size: ::std::option::Option<u32>,
    delta_report_crc: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDDeviceInputReport {
    fn default() -> &'a CHIDDeviceInputReport {
        <CHIDDeviceInputReport as ::protobuf::Message>::default_instance()
    }
}

impl CHIDDeviceInputReport {
    pub fn new() -> CHIDDeviceInputReport {
        ::std::default::Default::default()
    }

    // optional bytes full_report = 1;


    pub fn get_full_report(&self) -> &[u8] {
        match self.full_report.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_full_report(&mut self) {
        self.full_report.clear();
    }

    pub fn has_full_report(&self) -> bool {
        self.full_report.is_some()
    }

    // Param is passed by value, moved
    pub fn set_full_report(&mut self, v: ::std::vec::Vec<u8>) {
        self.full_report = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_full_report(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.full_report.is_none() {
            self.full_report.set_default();
        }
        self.full_report.as_mut().unwrap()
    }

    // Take field
    pub fn take_full_report(&mut self) -> ::std::vec::Vec<u8> {
        self.full_report.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional bytes delta_report = 2;


    pub fn get_delta_report(&self) -> &[u8] {
        match self.delta_report.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_delta_report(&mut self) {
        self.delta_report.clear();
    }

    pub fn has_delta_report(&self) -> bool {
        self.delta_report.is_some()
    }

    // Param is passed by value, moved
    pub fn set_delta_report(&mut self, v: ::std::vec::Vec<u8>) {
        self.delta_report = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_delta_report(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.delta_report.is_none() {
            self.delta_report.set_default();
        }
        self.delta_report.as_mut().unwrap()
    }

    // Take field
    pub fn take_delta_report(&mut self) -> ::std::vec::Vec<u8> {
        self.delta_report.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional uint32 delta_report_size = 3;


    pub fn get_delta_report_size(&self) -> u32 {
        self.delta_report_size.unwrap_or(0)
    }
    pub fn clear_delta_report_size(&mut self) {
        self.delta_report_size = ::std::option::Option::None;
    }

    pub fn has_delta_report_size(&self) -> bool {
        self.delta_report_size.is_some()
    }

    // Param is passed by value, moved
    pub fn set_delta_report_size(&mut self, v: u32) {
        self.delta_report_size = ::std::option::Option::Some(v);
    }

    // optional uint32 delta_report_crc = 4;


    pub fn get_delta_report_crc(&self) -> u32 {
        self.delta_report_crc.unwrap_or(0)
    }
    pub fn clear_delta_report_crc(&mut self) {
        self.delta_report_crc = ::std::option::Option::None;
    }

    pub fn has_delta_report_crc(&self) -> bool {
        self.delta_report_crc.is_some()
    }

    // Param is passed by value, moved
    pub fn set_delta_report_crc(&mut self, v: u32) {
        self.delta_report_crc = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CHIDDeviceInputReport {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.full_report)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.delta_report)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.delta_report_size = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.delta_report_crc = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.full_report.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(ref v) = self.delta_report.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(v) = self.delta_report_size {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.delta_report_crc {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.full_report.as_ref() {
            os.write_bytes(1, &v)?;
        }
        if let Some(ref v) = self.delta_report.as_ref() {
            os.write_bytes(2, &v)?;
        }
        if let Some(v) = self.delta_report_size {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.delta_report_crc {
            os.write_uint32(4, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDDeviceInputReport {
        CHIDDeviceInputReport::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "full_report",
                |m: &CHIDDeviceInputReport| { &m.full_report },
                |m: &mut CHIDDeviceInputReport| { &mut m.full_report },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "delta_report",
                |m: &CHIDDeviceInputReport| { &m.delta_report },
                |m: &mut CHIDDeviceInputReport| { &mut m.delta_report },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "delta_report_size",
                |m: &CHIDDeviceInputReport| { &m.delta_report_size },
                |m: &mut CHIDDeviceInputReport| { &mut m.delta_report_size },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "delta_report_crc",
                |m: &CHIDDeviceInputReport| { &m.delta_report_crc },
                |m: &mut CHIDDeviceInputReport| { &mut m.delta_report_crc },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDDeviceInputReport>(
                "CHIDDeviceInputReport",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDDeviceInputReport {
        static instance: ::protobuf::rt::LazyV2<CHIDDeviceInputReport> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDDeviceInputReport::new)
    }
}

impl ::protobuf::Clear for CHIDDeviceInputReport {
    fn clear(&mut self) {
        self.full_report.clear();
        self.delta_report.clear();
        self.delta_report_size = ::std::option::Option::None;
        self.delta_report_crc = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDDeviceInputReport {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDDeviceInputReport {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageToRemote {
    // message fields
    request_id: ::std::option::Option<u32>,
    // message oneof groups
    pub command: ::std::option::Option<CHIDMessageToRemote_oneof_command>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageToRemote {
    fn default() -> &'a CHIDMessageToRemote {
        <CHIDMessageToRemote as ::protobuf::Message>::default_instance()
    }
}

#[derive(Clone,PartialEq,Debug)]
pub enum CHIDMessageToRemote_oneof_command {
    device_open(CHIDMessageToRemote_DeviceOpen),
    device_close(CHIDMessageToRemote_DeviceClose),
    device_write(CHIDMessageToRemote_DeviceWrite),
    device_read(CHIDMessageToRemote_DeviceRead),
    device_send_feature_report(CHIDMessageToRemote_DeviceSendFeatureReport),
    device_get_feature_report(CHIDMessageToRemote_DeviceGetFeatureReport),
    device_get_vendor_string(CHIDMessageToRemote_DeviceGetVendorString),
    device_get_product_string(CHIDMessageToRemote_DeviceGetProductString),
    device_get_serial_number_string(CHIDMessageToRemote_DeviceGetSerialNumberString),
    device_start_input_reports(CHIDMessageToRemote_DeviceStartInputReports),
    device_request_full_report(CHIDMessageToRemote_DeviceRequestFullReport),
    device_disconnect(CHIDMessageToRemote_DeviceDisconnect),
}

impl CHIDMessageToRemote {
    pub fn new() -> CHIDMessageToRemote {
        ::std::default::Default::default()
    }

    // optional uint32 request_id = 1;


    pub fn get_request_id(&self) -> u32 {
        self.request_id.unwrap_or(0)
    }
    pub fn clear_request_id(&mut self) {
        self.request_id = ::std::option::Option::None;
    }

    pub fn has_request_id(&self) -> bool {
        self.request_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_request_id(&mut self, v: u32) {
        self.request_id = ::std::option::Option::Some(v);
    }

    // optional .CHIDMessageToRemote.DeviceOpen device_open = 2;


    pub fn get_device_open(&self) -> &CHIDMessageToRemote_DeviceOpen {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_open(ref v)) => v,
            _ => <CHIDMessageToRemote_DeviceOpen as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_device_open(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_device_open(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_open(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_device_open(&mut self, v: CHIDMessageToRemote_DeviceOpen) {
        self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_open(v))
    }

    // Mutable pointer to the field.
    pub fn mut_device_open(&mut self) -> &mut CHIDMessageToRemote_DeviceOpen {
        if let ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_open(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_open(CHIDMessageToRemote_DeviceOpen::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_open(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_device_open(&mut self) -> CHIDMessageToRemote_DeviceOpen {
        if self.has_device_open() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_open(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageToRemote_DeviceOpen::new()
        }
    }

    // optional .CHIDMessageToRemote.DeviceClose device_close = 3;


    pub fn get_device_close(&self) -> &CHIDMessageToRemote_DeviceClose {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_close(ref v)) => v,
            _ => <CHIDMessageToRemote_DeviceClose as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_device_close(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_device_close(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_close(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_device_close(&mut self, v: CHIDMessageToRemote_DeviceClose) {
        self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_close(v))
    }

    // Mutable pointer to the field.
    pub fn mut_device_close(&mut self) -> &mut CHIDMessageToRemote_DeviceClose {
        if let ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_close(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_close(CHIDMessageToRemote_DeviceClose::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_close(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_device_close(&mut self) -> CHIDMessageToRemote_DeviceClose {
        if self.has_device_close() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_close(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageToRemote_DeviceClose::new()
        }
    }

    // optional .CHIDMessageToRemote.DeviceWrite device_write = 4;


    pub fn get_device_write(&self) -> &CHIDMessageToRemote_DeviceWrite {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_write(ref v)) => v,
            _ => <CHIDMessageToRemote_DeviceWrite as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_device_write(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_device_write(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_write(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_device_write(&mut self, v: CHIDMessageToRemote_DeviceWrite) {
        self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_write(v))
    }

    // Mutable pointer to the field.
    pub fn mut_device_write(&mut self) -> &mut CHIDMessageToRemote_DeviceWrite {
        if let ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_write(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_write(CHIDMessageToRemote_DeviceWrite::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_write(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_device_write(&mut self) -> CHIDMessageToRemote_DeviceWrite {
        if self.has_device_write() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_write(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageToRemote_DeviceWrite::new()
        }
    }

    // optional .CHIDMessageToRemote.DeviceRead device_read = 5;


    pub fn get_device_read(&self) -> &CHIDMessageToRemote_DeviceRead {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_read(ref v)) => v,
            _ => <CHIDMessageToRemote_DeviceRead as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_device_read(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_device_read(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_read(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_device_read(&mut self, v: CHIDMessageToRemote_DeviceRead) {
        self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_read(v))
    }

    // Mutable pointer to the field.
    pub fn mut_device_read(&mut self) -> &mut CHIDMessageToRemote_DeviceRead {
        if let ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_read(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_read(CHIDMessageToRemote_DeviceRead::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_read(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_device_read(&mut self) -> CHIDMessageToRemote_DeviceRead {
        if self.has_device_read() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_read(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageToRemote_DeviceRead::new()
        }
    }

    // optional .CHIDMessageToRemote.DeviceSendFeatureReport device_send_feature_report = 6;


    pub fn get_device_send_feature_report(&self) -> &CHIDMessageToRemote_DeviceSendFeatureReport {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_send_feature_report(ref v)) => v,
            _ => <CHIDMessageToRemote_DeviceSendFeatureReport as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_device_send_feature_report(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_device_send_feature_report(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_send_feature_report(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_device_send_feature_report(&mut self, v: CHIDMessageToRemote_DeviceSendFeatureReport) {
        self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_send_feature_report(v))
    }

    // Mutable pointer to the field.
    pub fn mut_device_send_feature_report(&mut self) -> &mut CHIDMessageToRemote_DeviceSendFeatureReport {
        if let ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_send_feature_report(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_send_feature_report(CHIDMessageToRemote_DeviceSendFeatureReport::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_send_feature_report(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_device_send_feature_report(&mut self) -> CHIDMessageToRemote_DeviceSendFeatureReport {
        if self.has_device_send_feature_report() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_send_feature_report(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageToRemote_DeviceSendFeatureReport::new()
        }
    }

    // optional .CHIDMessageToRemote.DeviceGetFeatureReport device_get_feature_report = 7;


    pub fn get_device_get_feature_report(&self) -> &CHIDMessageToRemote_DeviceGetFeatureReport {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_feature_report(ref v)) => v,
            _ => <CHIDMessageToRemote_DeviceGetFeatureReport as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_device_get_feature_report(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_device_get_feature_report(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_feature_report(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_device_get_feature_report(&mut self, v: CHIDMessageToRemote_DeviceGetFeatureReport) {
        self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_feature_report(v))
    }

    // Mutable pointer to the field.
    pub fn mut_device_get_feature_report(&mut self) -> &mut CHIDMessageToRemote_DeviceGetFeatureReport {
        if let ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_feature_report(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_feature_report(CHIDMessageToRemote_DeviceGetFeatureReport::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_feature_report(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_device_get_feature_report(&mut self) -> CHIDMessageToRemote_DeviceGetFeatureReport {
        if self.has_device_get_feature_report() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_feature_report(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageToRemote_DeviceGetFeatureReport::new()
        }
    }

    // optional .CHIDMessageToRemote.DeviceGetVendorString device_get_vendor_string = 8;


    pub fn get_device_get_vendor_string(&self) -> &CHIDMessageToRemote_DeviceGetVendorString {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_vendor_string(ref v)) => v,
            _ => <CHIDMessageToRemote_DeviceGetVendorString as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_device_get_vendor_string(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_device_get_vendor_string(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_vendor_string(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_device_get_vendor_string(&mut self, v: CHIDMessageToRemote_DeviceGetVendorString) {
        self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_vendor_string(v))
    }

    // Mutable pointer to the field.
    pub fn mut_device_get_vendor_string(&mut self) -> &mut CHIDMessageToRemote_DeviceGetVendorString {
        if let ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_vendor_string(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_vendor_string(CHIDMessageToRemote_DeviceGetVendorString::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_vendor_string(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_device_get_vendor_string(&mut self) -> CHIDMessageToRemote_DeviceGetVendorString {
        if self.has_device_get_vendor_string() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_vendor_string(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageToRemote_DeviceGetVendorString::new()
        }
    }

    // optional .CHIDMessageToRemote.DeviceGetProductString device_get_product_string = 9;


    pub fn get_device_get_product_string(&self) -> &CHIDMessageToRemote_DeviceGetProductString {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_product_string(ref v)) => v,
            _ => <CHIDMessageToRemote_DeviceGetProductString as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_device_get_product_string(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_device_get_product_string(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_product_string(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_device_get_product_string(&mut self, v: CHIDMessageToRemote_DeviceGetProductString) {
        self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_product_string(v))
    }

    // Mutable pointer to the field.
    pub fn mut_device_get_product_string(&mut self) -> &mut CHIDMessageToRemote_DeviceGetProductString {
        if let ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_product_string(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_product_string(CHIDMessageToRemote_DeviceGetProductString::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_product_string(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_device_get_product_string(&mut self) -> CHIDMessageToRemote_DeviceGetProductString {
        if self.has_device_get_product_string() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_product_string(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageToRemote_DeviceGetProductString::new()
        }
    }

    // optional .CHIDMessageToRemote.DeviceGetSerialNumberString device_get_serial_number_string = 10;


    pub fn get_device_get_serial_number_string(&self) -> &CHIDMessageToRemote_DeviceGetSerialNumberString {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_serial_number_string(ref v)) => v,
            _ => <CHIDMessageToRemote_DeviceGetSerialNumberString as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_device_get_serial_number_string(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_device_get_serial_number_string(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_serial_number_string(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_device_get_serial_number_string(&mut self, v: CHIDMessageToRemote_DeviceGetSerialNumberString) {
        self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_serial_number_string(v))
    }

    // Mutable pointer to the field.
    pub fn mut_device_get_serial_number_string(&mut self) -> &mut CHIDMessageToRemote_DeviceGetSerialNumberString {
        if let ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_serial_number_string(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_serial_number_string(CHIDMessageToRemote_DeviceGetSerialNumberString::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_serial_number_string(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_device_get_serial_number_string(&mut self) -> CHIDMessageToRemote_DeviceGetSerialNumberString {
        if self.has_device_get_serial_number_string() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_serial_number_string(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageToRemote_DeviceGetSerialNumberString::new()
        }
    }

    // optional .CHIDMessageToRemote.DeviceStartInputReports device_start_input_reports = 11;


    pub fn get_device_start_input_reports(&self) -> &CHIDMessageToRemote_DeviceStartInputReports {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_start_input_reports(ref v)) => v,
            _ => <CHIDMessageToRemote_DeviceStartInputReports as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_device_start_input_reports(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_device_start_input_reports(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_start_input_reports(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_device_start_input_reports(&mut self, v: CHIDMessageToRemote_DeviceStartInputReports) {
        self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_start_input_reports(v))
    }

    // Mutable pointer to the field.
    pub fn mut_device_start_input_reports(&mut self) -> &mut CHIDMessageToRemote_DeviceStartInputReports {
        if let ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_start_input_reports(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_start_input_reports(CHIDMessageToRemote_DeviceStartInputReports::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_start_input_reports(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_device_start_input_reports(&mut self) -> CHIDMessageToRemote_DeviceStartInputReports {
        if self.has_device_start_input_reports() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_start_input_reports(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageToRemote_DeviceStartInputReports::new()
        }
    }

    // optional .CHIDMessageToRemote.DeviceRequestFullReport device_request_full_report = 12;


    pub fn get_device_request_full_report(&self) -> &CHIDMessageToRemote_DeviceRequestFullReport {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_request_full_report(ref v)) => v,
            _ => <CHIDMessageToRemote_DeviceRequestFullReport as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_device_request_full_report(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_device_request_full_report(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_request_full_report(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_device_request_full_report(&mut self, v: CHIDMessageToRemote_DeviceRequestFullReport) {
        self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_request_full_report(v))
    }

    // Mutable pointer to the field.
    pub fn mut_device_request_full_report(&mut self) -> &mut CHIDMessageToRemote_DeviceRequestFullReport {
        if let ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_request_full_report(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_request_full_report(CHIDMessageToRemote_DeviceRequestFullReport::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_request_full_report(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_device_request_full_report(&mut self) -> CHIDMessageToRemote_DeviceRequestFullReport {
        if self.has_device_request_full_report() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_request_full_report(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageToRemote_DeviceRequestFullReport::new()
        }
    }

    // optional .CHIDMessageToRemote.DeviceDisconnect device_disconnect = 13;


    pub fn get_device_disconnect(&self) -> &CHIDMessageToRemote_DeviceDisconnect {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_disconnect(ref v)) => v,
            _ => <CHIDMessageToRemote_DeviceDisconnect as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_device_disconnect(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_device_disconnect(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_disconnect(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_device_disconnect(&mut self, v: CHIDMessageToRemote_DeviceDisconnect) {
        self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_disconnect(v))
    }

    // Mutable pointer to the field.
    pub fn mut_device_disconnect(&mut self) -> &mut CHIDMessageToRemote_DeviceDisconnect {
        if let ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_disconnect(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_disconnect(CHIDMessageToRemote_DeviceDisconnect::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_disconnect(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_device_disconnect(&mut self) -> CHIDMessageToRemote_DeviceDisconnect {
        if self.has_device_disconnect() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_disconnect(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageToRemote_DeviceDisconnect::new()
        }
    }
}

impl ::protobuf::Message for CHIDMessageToRemote {
    fn is_initialized(&self) -> bool {
        if let Some(CHIDMessageToRemote_oneof_command::device_open(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CHIDMessageToRemote_oneof_command::device_close(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CHIDMessageToRemote_oneof_command::device_write(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CHIDMessageToRemote_oneof_command::device_read(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CHIDMessageToRemote_oneof_command::device_send_feature_report(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CHIDMessageToRemote_oneof_command::device_get_feature_report(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CHIDMessageToRemote_oneof_command::device_get_vendor_string(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CHIDMessageToRemote_oneof_command::device_get_product_string(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CHIDMessageToRemote_oneof_command::device_get_serial_number_string(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CHIDMessageToRemote_oneof_command::device_start_input_reports(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CHIDMessageToRemote_oneof_command::device_request_full_report(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CHIDMessageToRemote_oneof_command::device_disconnect(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.request_id = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_open(is.read_message()?));
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_close(is.read_message()?));
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_write(is.read_message()?));
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_read(is.read_message()?));
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_send_feature_report(is.read_message()?));
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_feature_report(is.read_message()?));
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_vendor_string(is.read_message()?));
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_product_string(is.read_message()?));
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_get_serial_number_string(is.read_message()?));
                },
                11 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_start_input_reports(is.read_message()?));
                },
                12 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_request_full_report(is.read_message()?));
                },
                13 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageToRemote_oneof_command::device_disconnect(is.read_message()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.request_id {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let ::std::option::Option::Some(ref v) = self.command {
            match v {
                &CHIDMessageToRemote_oneof_command::device_open(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CHIDMessageToRemote_oneof_command::device_close(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CHIDMessageToRemote_oneof_command::device_write(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CHIDMessageToRemote_oneof_command::device_read(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CHIDMessageToRemote_oneof_command::device_send_feature_report(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CHIDMessageToRemote_oneof_command::device_get_feature_report(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CHIDMessageToRemote_oneof_command::device_get_vendor_string(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CHIDMessageToRemote_oneof_command::device_get_product_string(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CHIDMessageToRemote_oneof_command::device_get_serial_number_string(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CHIDMessageToRemote_oneof_command::device_start_input_reports(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CHIDMessageToRemote_oneof_command::device_request_full_report(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CHIDMessageToRemote_oneof_command::device_disconnect(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.request_id {
            os.write_uint32(1, v)?;
        }
        if let ::std::option::Option::Some(ref v) = self.command {
            match v {
                &CHIDMessageToRemote_oneof_command::device_open(ref v) => {
                    os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CHIDMessageToRemote_oneof_command::device_close(ref v) => {
                    os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CHIDMessageToRemote_oneof_command::device_write(ref v) => {
                    os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CHIDMessageToRemote_oneof_command::device_read(ref v) => {
                    os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CHIDMessageToRemote_oneof_command::device_send_feature_report(ref v) => {
                    os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CHIDMessageToRemote_oneof_command::device_get_feature_report(ref v) => {
                    os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CHIDMessageToRemote_oneof_command::device_get_vendor_string(ref v) => {
                    os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CHIDMessageToRemote_oneof_command::device_get_product_string(ref v) => {
                    os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CHIDMessageToRemote_oneof_command::device_get_serial_number_string(ref v) => {
                    os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CHIDMessageToRemote_oneof_command::device_start_input_reports(ref v) => {
                    os.write_tag(11, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CHIDMessageToRemote_oneof_command::device_request_full_report(ref v) => {
                    os.write_tag(12, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CHIDMessageToRemote_oneof_command::device_disconnect(ref v) => {
                    os.write_tag(13, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
            };
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageToRemote {
        CHIDMessageToRemote::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "request_id",
                |m: &CHIDMessageToRemote| { &m.request_id },
                |m: &mut CHIDMessageToRemote| { &mut m.request_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageToRemote_DeviceOpen>(
                "device_open",
                CHIDMessageToRemote::has_device_open,
                CHIDMessageToRemote::get_device_open,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageToRemote_DeviceClose>(
                "device_close",
                CHIDMessageToRemote::has_device_close,
                CHIDMessageToRemote::get_device_close,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageToRemote_DeviceWrite>(
                "device_write",
                CHIDMessageToRemote::has_device_write,
                CHIDMessageToRemote::get_device_write,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageToRemote_DeviceRead>(
                "device_read",
                CHIDMessageToRemote::has_device_read,
                CHIDMessageToRemote::get_device_read,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageToRemote_DeviceSendFeatureReport>(
                "device_send_feature_report",
                CHIDMessageToRemote::has_device_send_feature_report,
                CHIDMessageToRemote::get_device_send_feature_report,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageToRemote_DeviceGetFeatureReport>(
                "device_get_feature_report",
                CHIDMessageToRemote::has_device_get_feature_report,
                CHIDMessageToRemote::get_device_get_feature_report,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageToRemote_DeviceGetVendorString>(
                "device_get_vendor_string",
                CHIDMessageToRemote::has_device_get_vendor_string,
                CHIDMessageToRemote::get_device_get_vendor_string,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageToRemote_DeviceGetProductString>(
                "device_get_product_string",
                CHIDMessageToRemote::has_device_get_product_string,
                CHIDMessageToRemote::get_device_get_product_string,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageToRemote_DeviceGetSerialNumberString>(
                "device_get_serial_number_string",
                CHIDMessageToRemote::has_device_get_serial_number_string,
                CHIDMessageToRemote::get_device_get_serial_number_string,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageToRemote_DeviceStartInputReports>(
                "device_start_input_reports",
                CHIDMessageToRemote::has_device_start_input_reports,
                CHIDMessageToRemote::get_device_start_input_reports,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageToRemote_DeviceRequestFullReport>(
                "device_request_full_report",
                CHIDMessageToRemote::has_device_request_full_report,
                CHIDMessageToRemote::get_device_request_full_report,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageToRemote_DeviceDisconnect>(
                "device_disconnect",
                CHIDMessageToRemote::has_device_disconnect,
                CHIDMessageToRemote::get_device_disconnect,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageToRemote>(
                "CHIDMessageToRemote",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageToRemote {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageToRemote> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageToRemote::new)
    }
}

impl ::protobuf::Clear for CHIDMessageToRemote {
    fn clear(&mut self) {
        self.request_id = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageToRemote {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageToRemote {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageToRemote_DeviceOpen {
    // message fields
    pub info: ::protobuf::SingularPtrField<CHIDDeviceInfo>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageToRemote_DeviceOpen {
    fn default() -> &'a CHIDMessageToRemote_DeviceOpen {
        <CHIDMessageToRemote_DeviceOpen as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageToRemote_DeviceOpen {
    pub fn new() -> CHIDMessageToRemote_DeviceOpen {
        ::std::default::Default::default()
    }

    // optional .CHIDDeviceInfo info = 1;


    pub fn get_info(&self) -> &CHIDDeviceInfo {
        self.info.as_ref().unwrap_or_else(|| <CHIDDeviceInfo as ::protobuf::Message>::default_instance())
    }
    pub fn clear_info(&mut self) {
        self.info.clear();
    }

    pub fn has_info(&self) -> bool {
        self.info.is_some()
    }

    // Param is passed by value, moved
    pub fn set_info(&mut self, v: CHIDDeviceInfo) {
        self.info = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_info(&mut self) -> &mut CHIDDeviceInfo {
        if self.info.is_none() {
            self.info.set_default();
        }
        self.info.as_mut().unwrap()
    }

    // Take field
    pub fn take_info(&mut self) -> CHIDDeviceInfo {
        self.info.take().unwrap_or_else(|| CHIDDeviceInfo::new())
    }
}

impl ::protobuf::Message for CHIDMessageToRemote_DeviceOpen {
    fn is_initialized(&self) -> bool {
        for v in &self.info {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.info)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.info.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.info.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageToRemote_DeviceOpen {
        CHIDMessageToRemote_DeviceOpen::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CHIDDeviceInfo>>(
                "info",
                |m: &CHIDMessageToRemote_DeviceOpen| { &m.info },
                |m: &mut CHIDMessageToRemote_DeviceOpen| { &mut m.info },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageToRemote_DeviceOpen>(
                "CHIDMessageToRemote.DeviceOpen",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageToRemote_DeviceOpen {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageToRemote_DeviceOpen> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageToRemote_DeviceOpen::new)
    }
}

impl ::protobuf::Clear for CHIDMessageToRemote_DeviceOpen {
    fn clear(&mut self) {
        self.info.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageToRemote_DeviceOpen {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageToRemote_DeviceOpen {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageToRemote_DeviceClose {
    // message fields
    device: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageToRemote_DeviceClose {
    fn default() -> &'a CHIDMessageToRemote_DeviceClose {
        <CHIDMessageToRemote_DeviceClose as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageToRemote_DeviceClose {
    pub fn new() -> CHIDMessageToRemote_DeviceClose {
        ::std::default::Default::default()
    }

    // optional uint32 device = 1;


    pub fn get_device(&self) -> u32 {
        self.device.unwrap_or(0)
    }
    pub fn clear_device(&mut self) {
        self.device = ::std::option::Option::None;
    }

    pub fn has_device(&self) -> bool {
        self.device.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device(&mut self, v: u32) {
        self.device = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CHIDMessageToRemote_DeviceClose {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.device = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.device {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.device {
            os.write_uint32(1, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageToRemote_DeviceClose {
        CHIDMessageToRemote_DeviceClose::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "device",
                |m: &CHIDMessageToRemote_DeviceClose| { &m.device },
                |m: &mut CHIDMessageToRemote_DeviceClose| { &mut m.device },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageToRemote_DeviceClose>(
                "CHIDMessageToRemote.DeviceClose",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageToRemote_DeviceClose {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageToRemote_DeviceClose> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageToRemote_DeviceClose::new)
    }
}

impl ::protobuf::Clear for CHIDMessageToRemote_DeviceClose {
    fn clear(&mut self) {
        self.device = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageToRemote_DeviceClose {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageToRemote_DeviceClose {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageToRemote_DeviceWrite {
    // message fields
    device: ::std::option::Option<u32>,
    data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageToRemote_DeviceWrite {
    fn default() -> &'a CHIDMessageToRemote_DeviceWrite {
        <CHIDMessageToRemote_DeviceWrite as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageToRemote_DeviceWrite {
    pub fn new() -> CHIDMessageToRemote_DeviceWrite {
        ::std::default::Default::default()
    }

    // optional uint32 device = 1;


    pub fn get_device(&self) -> u32 {
        self.device.unwrap_or(0)
    }
    pub fn clear_device(&mut self) {
        self.device = ::std::option::Option::None;
    }

    pub fn has_device(&self) -> bool {
        self.device.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device(&mut self, v: u32) {
        self.device = ::std::option::Option::Some(v);
    }

    // optional bytes data = 2;


    pub fn get_data(&self) -> &[u8] {
        match self.data.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_data(&mut self) {
        self.data.clear();
    }

    pub fn has_data(&self) -> bool {
        self.data.is_some()
    }

    // Param is passed by value, moved
    pub fn set_data(&mut self, v: ::std::vec::Vec<u8>) {
        self.data = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_data(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.data.is_none() {
            self.data.set_default();
        }
        self.data.as_mut().unwrap()
    }

    // Take field
    pub fn take_data(&mut self) -> ::std::vec::Vec<u8> {
        self.data.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for CHIDMessageToRemote_DeviceWrite {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.device = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.data)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.device {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.data.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.device {
            os.write_uint32(1, v)?;
        }
        if let Some(ref v) = self.data.as_ref() {
            os.write_bytes(2, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageToRemote_DeviceWrite {
        CHIDMessageToRemote_DeviceWrite::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "device",
                |m: &CHIDMessageToRemote_DeviceWrite| { &m.device },
                |m: &mut CHIDMessageToRemote_DeviceWrite| { &mut m.device },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "data",
                |m: &CHIDMessageToRemote_DeviceWrite| { &m.data },
                |m: &mut CHIDMessageToRemote_DeviceWrite| { &mut m.data },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageToRemote_DeviceWrite>(
                "CHIDMessageToRemote.DeviceWrite",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageToRemote_DeviceWrite {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageToRemote_DeviceWrite> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageToRemote_DeviceWrite::new)
    }
}

impl ::protobuf::Clear for CHIDMessageToRemote_DeviceWrite {
    fn clear(&mut self) {
        self.device = ::std::option::Option::None;
        self.data.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageToRemote_DeviceWrite {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageToRemote_DeviceWrite {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageToRemote_DeviceRead {
    // message fields
    device: ::std::option::Option<u32>,
    length: ::std::option::Option<u32>,
    timeout_ms: ::std::option::Option<i32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageToRemote_DeviceRead {
    fn default() -> &'a CHIDMessageToRemote_DeviceRead {
        <CHIDMessageToRemote_DeviceRead as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageToRemote_DeviceRead {
    pub fn new() -> CHIDMessageToRemote_DeviceRead {
        ::std::default::Default::default()
    }

    // optional uint32 device = 1;


    pub fn get_device(&self) -> u32 {
        self.device.unwrap_or(0)
    }
    pub fn clear_device(&mut self) {
        self.device = ::std::option::Option::None;
    }

    pub fn has_device(&self) -> bool {
        self.device.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device(&mut self, v: u32) {
        self.device = ::std::option::Option::Some(v);
    }

    // optional uint32 length = 2;


    pub fn get_length(&self) -> u32 {
        self.length.unwrap_or(0)
    }
    pub fn clear_length(&mut self) {
        self.length = ::std::option::Option::None;
    }

    pub fn has_length(&self) -> bool {
        self.length.is_some()
    }

    // Param is passed by value, moved
    pub fn set_length(&mut self, v: u32) {
        self.length = ::std::option::Option::Some(v);
    }

    // optional int32 timeout_ms = 3;


    pub fn get_timeout_ms(&self) -> i32 {
        self.timeout_ms.unwrap_or(0)
    }
    pub fn clear_timeout_ms(&mut self) {
        self.timeout_ms = ::std::option::Option::None;
    }

    pub fn has_timeout_ms(&self) -> bool {
        self.timeout_ms.is_some()
    }

    // Param is passed by value, moved
    pub fn set_timeout_ms(&mut self, v: i32) {
        self.timeout_ms = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CHIDMessageToRemote_DeviceRead {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.device = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.length = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.timeout_ms = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.device {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.length {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.timeout_ms {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.device {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.length {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.timeout_ms {
            os.write_int32(3, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageToRemote_DeviceRead {
        CHIDMessageToRemote_DeviceRead::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "device",
                |m: &CHIDMessageToRemote_DeviceRead| { &m.device },
                |m: &mut CHIDMessageToRemote_DeviceRead| { &mut m.device },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "length",
                |m: &CHIDMessageToRemote_DeviceRead| { &m.length },
                |m: &mut CHIDMessageToRemote_DeviceRead| { &mut m.length },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "timeout_ms",
                |m: &CHIDMessageToRemote_DeviceRead| { &m.timeout_ms },
                |m: &mut CHIDMessageToRemote_DeviceRead| { &mut m.timeout_ms },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageToRemote_DeviceRead>(
                "CHIDMessageToRemote.DeviceRead",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageToRemote_DeviceRead {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageToRemote_DeviceRead> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageToRemote_DeviceRead::new)
    }
}

impl ::protobuf::Clear for CHIDMessageToRemote_DeviceRead {
    fn clear(&mut self) {
        self.device = ::std::option::Option::None;
        self.length = ::std::option::Option::None;
        self.timeout_ms = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageToRemote_DeviceRead {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageToRemote_DeviceRead {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageToRemote_DeviceSendFeatureReport {
    // message fields
    device: ::std::option::Option<u32>,
    data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageToRemote_DeviceSendFeatureReport {
    fn default() -> &'a CHIDMessageToRemote_DeviceSendFeatureReport {
        <CHIDMessageToRemote_DeviceSendFeatureReport as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageToRemote_DeviceSendFeatureReport {
    pub fn new() -> CHIDMessageToRemote_DeviceSendFeatureReport {
        ::std::default::Default::default()
    }

    // optional uint32 device = 1;


    pub fn get_device(&self) -> u32 {
        self.device.unwrap_or(0)
    }
    pub fn clear_device(&mut self) {
        self.device = ::std::option::Option::None;
    }

    pub fn has_device(&self) -> bool {
        self.device.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device(&mut self, v: u32) {
        self.device = ::std::option::Option::Some(v);
    }

    // optional bytes data = 2;


    pub fn get_data(&self) -> &[u8] {
        match self.data.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_data(&mut self) {
        self.data.clear();
    }

    pub fn has_data(&self) -> bool {
        self.data.is_some()
    }

    // Param is passed by value, moved
    pub fn set_data(&mut self, v: ::std::vec::Vec<u8>) {
        self.data = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_data(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.data.is_none() {
            self.data.set_default();
        }
        self.data.as_mut().unwrap()
    }

    // Take field
    pub fn take_data(&mut self) -> ::std::vec::Vec<u8> {
        self.data.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for CHIDMessageToRemote_DeviceSendFeatureReport {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.device = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.data)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.device {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.data.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.device {
            os.write_uint32(1, v)?;
        }
        if let Some(ref v) = self.data.as_ref() {
            os.write_bytes(2, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageToRemote_DeviceSendFeatureReport {
        CHIDMessageToRemote_DeviceSendFeatureReport::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "device",
                |m: &CHIDMessageToRemote_DeviceSendFeatureReport| { &m.device },
                |m: &mut CHIDMessageToRemote_DeviceSendFeatureReport| { &mut m.device },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "data",
                |m: &CHIDMessageToRemote_DeviceSendFeatureReport| { &m.data },
                |m: &mut CHIDMessageToRemote_DeviceSendFeatureReport| { &mut m.data },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageToRemote_DeviceSendFeatureReport>(
                "CHIDMessageToRemote.DeviceSendFeatureReport",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageToRemote_DeviceSendFeatureReport {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageToRemote_DeviceSendFeatureReport> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageToRemote_DeviceSendFeatureReport::new)
    }
}

impl ::protobuf::Clear for CHIDMessageToRemote_DeviceSendFeatureReport {
    fn clear(&mut self) {
        self.device = ::std::option::Option::None;
        self.data.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageToRemote_DeviceSendFeatureReport {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageToRemote_DeviceSendFeatureReport {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageToRemote_DeviceGetFeatureReport {
    // message fields
    device: ::std::option::Option<u32>,
    report_number: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    length: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageToRemote_DeviceGetFeatureReport {
    fn default() -> &'a CHIDMessageToRemote_DeviceGetFeatureReport {
        <CHIDMessageToRemote_DeviceGetFeatureReport as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageToRemote_DeviceGetFeatureReport {
    pub fn new() -> CHIDMessageToRemote_DeviceGetFeatureReport {
        ::std::default::Default::default()
    }

    // optional uint32 device = 1;


    pub fn get_device(&self) -> u32 {
        self.device.unwrap_or(0)
    }
    pub fn clear_device(&mut self) {
        self.device = ::std::option::Option::None;
    }

    pub fn has_device(&self) -> bool {
        self.device.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device(&mut self, v: u32) {
        self.device = ::std::option::Option::Some(v);
    }

    // optional bytes report_number = 2;


    pub fn get_report_number(&self) -> &[u8] {
        match self.report_number.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_report_number(&mut self) {
        self.report_number.clear();
    }

    pub fn has_report_number(&self) -> bool {
        self.report_number.is_some()
    }

    // Param is passed by value, moved
    pub fn set_report_number(&mut self, v: ::std::vec::Vec<u8>) {
        self.report_number = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_report_number(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.report_number.is_none() {
            self.report_number.set_default();
        }
        self.report_number.as_mut().unwrap()
    }

    // Take field
    pub fn take_report_number(&mut self) -> ::std::vec::Vec<u8> {
        self.report_number.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional uint32 length = 3;


    pub fn get_length(&self) -> u32 {
        self.length.unwrap_or(0)
    }
    pub fn clear_length(&mut self) {
        self.length = ::std::option::Option::None;
    }

    pub fn has_length(&self) -> bool {
        self.length.is_some()
    }

    // Param is passed by value, moved
    pub fn set_length(&mut self, v: u32) {
        self.length = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CHIDMessageToRemote_DeviceGetFeatureReport {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.device = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.report_number)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.length = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.device {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.report_number.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(v) = self.length {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.device {
            os.write_uint32(1, v)?;
        }
        if let Some(ref v) = self.report_number.as_ref() {
            os.write_bytes(2, &v)?;
        }
        if let Some(v) = self.length {
            os.write_uint32(3, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageToRemote_DeviceGetFeatureReport {
        CHIDMessageToRemote_DeviceGetFeatureReport::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "device",
                |m: &CHIDMessageToRemote_DeviceGetFeatureReport| { &m.device },
                |m: &mut CHIDMessageToRemote_DeviceGetFeatureReport| { &mut m.device },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "report_number",
                |m: &CHIDMessageToRemote_DeviceGetFeatureReport| { &m.report_number },
                |m: &mut CHIDMessageToRemote_DeviceGetFeatureReport| { &mut m.report_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "length",
                |m: &CHIDMessageToRemote_DeviceGetFeatureReport| { &m.length },
                |m: &mut CHIDMessageToRemote_DeviceGetFeatureReport| { &mut m.length },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageToRemote_DeviceGetFeatureReport>(
                "CHIDMessageToRemote.DeviceGetFeatureReport",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageToRemote_DeviceGetFeatureReport {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageToRemote_DeviceGetFeatureReport> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageToRemote_DeviceGetFeatureReport::new)
    }
}

impl ::protobuf::Clear for CHIDMessageToRemote_DeviceGetFeatureReport {
    fn clear(&mut self) {
        self.device = ::std::option::Option::None;
        self.report_number.clear();
        self.length = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageToRemote_DeviceGetFeatureReport {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageToRemote_DeviceGetFeatureReport {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageToRemote_DeviceGetVendorString {
    // message fields
    device: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageToRemote_DeviceGetVendorString {
    fn default() -> &'a CHIDMessageToRemote_DeviceGetVendorString {
        <CHIDMessageToRemote_DeviceGetVendorString as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageToRemote_DeviceGetVendorString {
    pub fn new() -> CHIDMessageToRemote_DeviceGetVendorString {
        ::std::default::Default::default()
    }

    // optional uint32 device = 1;


    pub fn get_device(&self) -> u32 {
        self.device.unwrap_or(0)
    }
    pub fn clear_device(&mut self) {
        self.device = ::std::option::Option::None;
    }

    pub fn has_device(&self) -> bool {
        self.device.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device(&mut self, v: u32) {
        self.device = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CHIDMessageToRemote_DeviceGetVendorString {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.device = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.device {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.device {
            os.write_uint32(1, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageToRemote_DeviceGetVendorString {
        CHIDMessageToRemote_DeviceGetVendorString::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "device",
                |m: &CHIDMessageToRemote_DeviceGetVendorString| { &m.device },
                |m: &mut CHIDMessageToRemote_DeviceGetVendorString| { &mut m.device },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageToRemote_DeviceGetVendorString>(
                "CHIDMessageToRemote.DeviceGetVendorString",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageToRemote_DeviceGetVendorString {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageToRemote_DeviceGetVendorString> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageToRemote_DeviceGetVendorString::new)
    }
}

impl ::protobuf::Clear for CHIDMessageToRemote_DeviceGetVendorString {
    fn clear(&mut self) {
        self.device = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageToRemote_DeviceGetVendorString {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageToRemote_DeviceGetVendorString {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageToRemote_DeviceGetProductString {
    // message fields
    device: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageToRemote_DeviceGetProductString {
    fn default() -> &'a CHIDMessageToRemote_DeviceGetProductString {
        <CHIDMessageToRemote_DeviceGetProductString as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageToRemote_DeviceGetProductString {
    pub fn new() -> CHIDMessageToRemote_DeviceGetProductString {
        ::std::default::Default::default()
    }

    // optional uint32 device = 1;


    pub fn get_device(&self) -> u32 {
        self.device.unwrap_or(0)
    }
    pub fn clear_device(&mut self) {
        self.device = ::std::option::Option::None;
    }

    pub fn has_device(&self) -> bool {
        self.device.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device(&mut self, v: u32) {
        self.device = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CHIDMessageToRemote_DeviceGetProductString {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.device = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.device {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.device {
            os.write_uint32(1, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageToRemote_DeviceGetProductString {
        CHIDMessageToRemote_DeviceGetProductString::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "device",
                |m: &CHIDMessageToRemote_DeviceGetProductString| { &m.device },
                |m: &mut CHIDMessageToRemote_DeviceGetProductString| { &mut m.device },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageToRemote_DeviceGetProductString>(
                "CHIDMessageToRemote.DeviceGetProductString",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageToRemote_DeviceGetProductString {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageToRemote_DeviceGetProductString> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageToRemote_DeviceGetProductString::new)
    }
}

impl ::protobuf::Clear for CHIDMessageToRemote_DeviceGetProductString {
    fn clear(&mut self) {
        self.device = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageToRemote_DeviceGetProductString {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageToRemote_DeviceGetProductString {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageToRemote_DeviceGetSerialNumberString {
    // message fields
    device: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageToRemote_DeviceGetSerialNumberString {
    fn default() -> &'a CHIDMessageToRemote_DeviceGetSerialNumberString {
        <CHIDMessageToRemote_DeviceGetSerialNumberString as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageToRemote_DeviceGetSerialNumberString {
    pub fn new() -> CHIDMessageToRemote_DeviceGetSerialNumberString {
        ::std::default::Default::default()
    }

    // optional uint32 device = 1;


    pub fn get_device(&self) -> u32 {
        self.device.unwrap_or(0)
    }
    pub fn clear_device(&mut self) {
        self.device = ::std::option::Option::None;
    }

    pub fn has_device(&self) -> bool {
        self.device.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device(&mut self, v: u32) {
        self.device = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CHIDMessageToRemote_DeviceGetSerialNumberString {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.device = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.device {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.device {
            os.write_uint32(1, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageToRemote_DeviceGetSerialNumberString {
        CHIDMessageToRemote_DeviceGetSerialNumberString::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "device",
                |m: &CHIDMessageToRemote_DeviceGetSerialNumberString| { &m.device },
                |m: &mut CHIDMessageToRemote_DeviceGetSerialNumberString| { &mut m.device },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageToRemote_DeviceGetSerialNumberString>(
                "CHIDMessageToRemote.DeviceGetSerialNumberString",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageToRemote_DeviceGetSerialNumberString {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageToRemote_DeviceGetSerialNumberString> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageToRemote_DeviceGetSerialNumberString::new)
    }
}

impl ::protobuf::Clear for CHIDMessageToRemote_DeviceGetSerialNumberString {
    fn clear(&mut self) {
        self.device = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageToRemote_DeviceGetSerialNumberString {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageToRemote_DeviceGetSerialNumberString {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageToRemote_DeviceStartInputReports {
    // message fields
    device: ::std::option::Option<u32>,
    length: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageToRemote_DeviceStartInputReports {
    fn default() -> &'a CHIDMessageToRemote_DeviceStartInputReports {
        <CHIDMessageToRemote_DeviceStartInputReports as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageToRemote_DeviceStartInputReports {
    pub fn new() -> CHIDMessageToRemote_DeviceStartInputReports {
        ::std::default::Default::default()
    }

    // optional uint32 device = 1;


    pub fn get_device(&self) -> u32 {
        self.device.unwrap_or(0)
    }
    pub fn clear_device(&mut self) {
        self.device = ::std::option::Option::None;
    }

    pub fn has_device(&self) -> bool {
        self.device.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device(&mut self, v: u32) {
        self.device = ::std::option::Option::Some(v);
    }

    // optional uint32 length = 2;


    pub fn get_length(&self) -> u32 {
        self.length.unwrap_or(0)
    }
    pub fn clear_length(&mut self) {
        self.length = ::std::option::Option::None;
    }

    pub fn has_length(&self) -> bool {
        self.length.is_some()
    }

    // Param is passed by value, moved
    pub fn set_length(&mut self, v: u32) {
        self.length = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CHIDMessageToRemote_DeviceStartInputReports {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.device = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.length = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.device {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.length {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.device {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.length {
            os.write_uint32(2, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageToRemote_DeviceStartInputReports {
        CHIDMessageToRemote_DeviceStartInputReports::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "device",
                |m: &CHIDMessageToRemote_DeviceStartInputReports| { &m.device },
                |m: &mut CHIDMessageToRemote_DeviceStartInputReports| { &mut m.device },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "length",
                |m: &CHIDMessageToRemote_DeviceStartInputReports| { &m.length },
                |m: &mut CHIDMessageToRemote_DeviceStartInputReports| { &mut m.length },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageToRemote_DeviceStartInputReports>(
                "CHIDMessageToRemote.DeviceStartInputReports",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageToRemote_DeviceStartInputReports {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageToRemote_DeviceStartInputReports> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageToRemote_DeviceStartInputReports::new)
    }
}

impl ::protobuf::Clear for CHIDMessageToRemote_DeviceStartInputReports {
    fn clear(&mut self) {
        self.device = ::std::option::Option::None;
        self.length = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageToRemote_DeviceStartInputReports {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageToRemote_DeviceStartInputReports {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageToRemote_DeviceRequestFullReport {
    // message fields
    device: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageToRemote_DeviceRequestFullReport {
    fn default() -> &'a CHIDMessageToRemote_DeviceRequestFullReport {
        <CHIDMessageToRemote_DeviceRequestFullReport as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageToRemote_DeviceRequestFullReport {
    pub fn new() -> CHIDMessageToRemote_DeviceRequestFullReport {
        ::std::default::Default::default()
    }

    // optional uint32 device = 1;


    pub fn get_device(&self) -> u32 {
        self.device.unwrap_or(0)
    }
    pub fn clear_device(&mut self) {
        self.device = ::std::option::Option::None;
    }

    pub fn has_device(&self) -> bool {
        self.device.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device(&mut self, v: u32) {
        self.device = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CHIDMessageToRemote_DeviceRequestFullReport {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.device = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.device {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.device {
            os.write_uint32(1, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageToRemote_DeviceRequestFullReport {
        CHIDMessageToRemote_DeviceRequestFullReport::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "device",
                |m: &CHIDMessageToRemote_DeviceRequestFullReport| { &m.device },
                |m: &mut CHIDMessageToRemote_DeviceRequestFullReport| { &mut m.device },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageToRemote_DeviceRequestFullReport>(
                "CHIDMessageToRemote.DeviceRequestFullReport",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageToRemote_DeviceRequestFullReport {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageToRemote_DeviceRequestFullReport> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageToRemote_DeviceRequestFullReport::new)
    }
}

impl ::protobuf::Clear for CHIDMessageToRemote_DeviceRequestFullReport {
    fn clear(&mut self) {
        self.device = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageToRemote_DeviceRequestFullReport {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageToRemote_DeviceRequestFullReport {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageToRemote_DeviceDisconnect {
    // message fields
    device: ::std::option::Option<u32>,
    disconnectMethod: ::std::option::Option<EHIDDeviceDisconnectMethod>,
    data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageToRemote_DeviceDisconnect {
    fn default() -> &'a CHIDMessageToRemote_DeviceDisconnect {
        <CHIDMessageToRemote_DeviceDisconnect as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageToRemote_DeviceDisconnect {
    pub fn new() -> CHIDMessageToRemote_DeviceDisconnect {
        ::std::default::Default::default()
    }

    // optional uint32 device = 1;


    pub fn get_device(&self) -> u32 {
        self.device.unwrap_or(0)
    }
    pub fn clear_device(&mut self) {
        self.device = ::std::option::Option::None;
    }

    pub fn has_device(&self) -> bool {
        self.device.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device(&mut self, v: u32) {
        self.device = ::std::option::Option::Some(v);
    }

    // optional .EHIDDeviceDisconnectMethod disconnectMethod = 2;


    pub fn get_disconnectMethod(&self) -> EHIDDeviceDisconnectMethod {
        self.disconnectMethod.unwrap_or(EHIDDeviceDisconnectMethod::k_EDeviceDisconnectMethodUnknown)
    }
    pub fn clear_disconnectMethod(&mut self) {
        self.disconnectMethod = ::std::option::Option::None;
    }

    pub fn has_disconnectMethod(&self) -> bool {
        self.disconnectMethod.is_some()
    }

    // Param is passed by value, moved
    pub fn set_disconnectMethod(&mut self, v: EHIDDeviceDisconnectMethod) {
        self.disconnectMethod = ::std::option::Option::Some(v);
    }

    // optional bytes data = 3;


    pub fn get_data(&self) -> &[u8] {
        match self.data.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_data(&mut self) {
        self.data.clear();
    }

    pub fn has_data(&self) -> bool {
        self.data.is_some()
    }

    // Param is passed by value, moved
    pub fn set_data(&mut self, v: ::std::vec::Vec<u8>) {
        self.data = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_data(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.data.is_none() {
            self.data.set_default();
        }
        self.data.as_mut().unwrap()
    }

    // Take field
    pub fn take_data(&mut self) -> ::std::vec::Vec<u8> {
        self.data.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for CHIDMessageToRemote_DeviceDisconnect {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.device = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.disconnectMethod, 2, &mut self.unknown_fields)?
                },
                3 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.data)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.device {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.disconnectMethod {
            my_size += ::protobuf::rt::enum_size(2, v);
        }
        if let Some(ref v) = self.data.as_ref() {
            my_size += ::protobuf::rt::bytes_size(3, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.device {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.disconnectMethod {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&v))?;
        }
        if let Some(ref v) = self.data.as_ref() {
            os.write_bytes(3, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageToRemote_DeviceDisconnect {
        CHIDMessageToRemote_DeviceDisconnect::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "device",
                |m: &CHIDMessageToRemote_DeviceDisconnect| { &m.device },
                |m: &mut CHIDMessageToRemote_DeviceDisconnect| { &mut m.device },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EHIDDeviceDisconnectMethod>>(
                "disconnectMethod",
                |m: &CHIDMessageToRemote_DeviceDisconnect| { &m.disconnectMethod },
                |m: &mut CHIDMessageToRemote_DeviceDisconnect| { &mut m.disconnectMethod },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "data",
                |m: &CHIDMessageToRemote_DeviceDisconnect| { &m.data },
                |m: &mut CHIDMessageToRemote_DeviceDisconnect| { &mut m.data },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageToRemote_DeviceDisconnect>(
                "CHIDMessageToRemote.DeviceDisconnect",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageToRemote_DeviceDisconnect {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageToRemote_DeviceDisconnect> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageToRemote_DeviceDisconnect::new)
    }
}

impl ::protobuf::Clear for CHIDMessageToRemote_DeviceDisconnect {
    fn clear(&mut self) {
        self.device = ::std::option::Option::None;
        self.disconnectMethod = ::std::option::Option::None;
        self.data.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageToRemote_DeviceDisconnect {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageToRemote_DeviceDisconnect {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageFromRemote {
    // message oneof groups
    pub command: ::std::option::Option<CHIDMessageFromRemote_oneof_command>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageFromRemote {
    fn default() -> &'a CHIDMessageFromRemote {
        <CHIDMessageFromRemote as ::protobuf::Message>::default_instance()
    }
}

#[derive(Clone,PartialEq,Debug)]
pub enum CHIDMessageFromRemote_oneof_command {
    update_device_list(CHIDMessageFromRemote_UpdateDeviceList),
    response(CHIDMessageFromRemote_RequestResponse),
    reports(CHIDMessageFromRemote_DeviceInputReports),
    close_device(CHIDMessageFromRemote_CloseDevice),
    close_all_devices(CHIDMessageFromRemote_CloseAllDevices),
}

impl CHIDMessageFromRemote {
    pub fn new() -> CHIDMessageFromRemote {
        ::std::default::Default::default()
    }

    // optional .CHIDMessageFromRemote.UpdateDeviceList update_device_list = 1;


    pub fn get_update_device_list(&self) -> &CHIDMessageFromRemote_UpdateDeviceList {
        match self.command {
            ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::update_device_list(ref v)) => v,
            _ => <CHIDMessageFromRemote_UpdateDeviceList as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_update_device_list(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_update_device_list(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::update_device_list(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_update_device_list(&mut self, v: CHIDMessageFromRemote_UpdateDeviceList) {
        self.command = ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::update_device_list(v))
    }

    // Mutable pointer to the field.
    pub fn mut_update_device_list(&mut self) -> &mut CHIDMessageFromRemote_UpdateDeviceList {
        if let ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::update_device_list(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::update_device_list(CHIDMessageFromRemote_UpdateDeviceList::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::update_device_list(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_update_device_list(&mut self) -> CHIDMessageFromRemote_UpdateDeviceList {
        if self.has_update_device_list() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::update_device_list(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageFromRemote_UpdateDeviceList::new()
        }
    }

    // optional .CHIDMessageFromRemote.RequestResponse response = 2;


    pub fn get_response(&self) -> &CHIDMessageFromRemote_RequestResponse {
        match self.command {
            ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::response(ref v)) => v,
            _ => <CHIDMessageFromRemote_RequestResponse as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_response(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_response(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::response(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_response(&mut self, v: CHIDMessageFromRemote_RequestResponse) {
        self.command = ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::response(v))
    }

    // Mutable pointer to the field.
    pub fn mut_response(&mut self) -> &mut CHIDMessageFromRemote_RequestResponse {
        if let ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::response(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::response(CHIDMessageFromRemote_RequestResponse::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::response(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_response(&mut self) -> CHIDMessageFromRemote_RequestResponse {
        if self.has_response() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::response(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageFromRemote_RequestResponse::new()
        }
    }

    // optional .CHIDMessageFromRemote.DeviceInputReports reports = 3;


    pub fn get_reports(&self) -> &CHIDMessageFromRemote_DeviceInputReports {
        match self.command {
            ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::reports(ref v)) => v,
            _ => <CHIDMessageFromRemote_DeviceInputReports as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_reports(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_reports(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::reports(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_reports(&mut self, v: CHIDMessageFromRemote_DeviceInputReports) {
        self.command = ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::reports(v))
    }

    // Mutable pointer to the field.
    pub fn mut_reports(&mut self) -> &mut CHIDMessageFromRemote_DeviceInputReports {
        if let ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::reports(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::reports(CHIDMessageFromRemote_DeviceInputReports::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::reports(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_reports(&mut self) -> CHIDMessageFromRemote_DeviceInputReports {
        if self.has_reports() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::reports(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageFromRemote_DeviceInputReports::new()
        }
    }

    // optional .CHIDMessageFromRemote.CloseDevice close_device = 4;


    pub fn get_close_device(&self) -> &CHIDMessageFromRemote_CloseDevice {
        match self.command {
            ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_device(ref v)) => v,
            _ => <CHIDMessageFromRemote_CloseDevice as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_close_device(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_close_device(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_device(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_close_device(&mut self, v: CHIDMessageFromRemote_CloseDevice) {
        self.command = ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_device(v))
    }

    // Mutable pointer to the field.
    pub fn mut_close_device(&mut self) -> &mut CHIDMessageFromRemote_CloseDevice {
        if let ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_device(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_device(CHIDMessageFromRemote_CloseDevice::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_device(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_close_device(&mut self) -> CHIDMessageFromRemote_CloseDevice {
        if self.has_close_device() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_device(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageFromRemote_CloseDevice::new()
        }
    }

    // optional .CHIDMessageFromRemote.CloseAllDevices close_all_devices = 5;


    pub fn get_close_all_devices(&self) -> &CHIDMessageFromRemote_CloseAllDevices {
        match self.command {
            ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_all_devices(ref v)) => v,
            _ => <CHIDMessageFromRemote_CloseAllDevices as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_close_all_devices(&mut self) {
        self.command = ::std::option::Option::None;
    }

    pub fn has_close_all_devices(&self) -> bool {
        match self.command {
            ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_all_devices(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_close_all_devices(&mut self, v: CHIDMessageFromRemote_CloseAllDevices) {
        self.command = ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_all_devices(v))
    }

    // Mutable pointer to the field.
    pub fn mut_close_all_devices(&mut self) -> &mut CHIDMessageFromRemote_CloseAllDevices {
        if let ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_all_devices(_)) = self.command {
        } else {
            self.command = ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_all_devices(CHIDMessageFromRemote_CloseAllDevices::new()));
        }
        match self.command {
            ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_all_devices(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_close_all_devices(&mut self) -> CHIDMessageFromRemote_CloseAllDevices {
        if self.has_close_all_devices() {
            match self.command.take() {
                ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_all_devices(v)) => v,
                _ => panic!(),
            }
        } else {
            CHIDMessageFromRemote_CloseAllDevices::new()
        }
    }
}

impl ::protobuf::Message for CHIDMessageFromRemote {
    fn is_initialized(&self) -> bool {
        if let Some(CHIDMessageFromRemote_oneof_command::update_device_list(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CHIDMessageFromRemote_oneof_command::response(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CHIDMessageFromRemote_oneof_command::reports(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CHIDMessageFromRemote_oneof_command::close_device(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CHIDMessageFromRemote_oneof_command::close_all_devices(ref v)) = self.command {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::update_device_list(is.read_message()?));
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::response(is.read_message()?));
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::reports(is.read_message()?));
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_device(is.read_message()?));
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.command = ::std::option::Option::Some(CHIDMessageFromRemote_oneof_command::close_all_devices(is.read_message()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.command {
            match v {
                &CHIDMessageFromRemote_oneof_command::update_device_list(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CHIDMessageFromRemote_oneof_command::response(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CHIDMessageFromRemote_oneof_command::reports(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CHIDMessageFromRemote_oneof_command::close_device(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CHIDMessageFromRemote_oneof_command::close_all_devices(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let ::std::option::Option::Some(ref v) = self.command {
            match v {
                &CHIDMessageFromRemote_oneof_command::update_device_list(ref v) => {
                    os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CHIDMessageFromRemote_oneof_command::response(ref v) => {
                    os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CHIDMessageFromRemote_oneof_command::reports(ref v) => {
                    os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CHIDMessageFromRemote_oneof_command::close_device(ref v) => {
                    os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CHIDMessageFromRemote_oneof_command::close_all_devices(ref v) => {
                    os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
            };
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageFromRemote {
        CHIDMessageFromRemote::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageFromRemote_UpdateDeviceList>(
                "update_device_list",
                CHIDMessageFromRemote::has_update_device_list,
                CHIDMessageFromRemote::get_update_device_list,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageFromRemote_RequestResponse>(
                "response",
                CHIDMessageFromRemote::has_response,
                CHIDMessageFromRemote::get_response,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageFromRemote_DeviceInputReports>(
                "reports",
                CHIDMessageFromRemote::has_reports,
                CHIDMessageFromRemote::get_reports,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageFromRemote_CloseDevice>(
                "close_device",
                CHIDMessageFromRemote::has_close_device,
                CHIDMessageFromRemote::get_close_device,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CHIDMessageFromRemote_CloseAllDevices>(
                "close_all_devices",
                CHIDMessageFromRemote::has_close_all_devices,
                CHIDMessageFromRemote::get_close_all_devices,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageFromRemote>(
                "CHIDMessageFromRemote",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageFromRemote {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageFromRemote> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageFromRemote::new)
    }
}

impl ::protobuf::Clear for CHIDMessageFromRemote {
    fn clear(&mut self) {
        self.command = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.command = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageFromRemote {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageFromRemote {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageFromRemote_UpdateDeviceList {
    // message fields
    pub devices: ::protobuf::RepeatedField<CHIDDeviceInfo>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageFromRemote_UpdateDeviceList {
    fn default() -> &'a CHIDMessageFromRemote_UpdateDeviceList {
        <CHIDMessageFromRemote_UpdateDeviceList as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageFromRemote_UpdateDeviceList {
    pub fn new() -> CHIDMessageFromRemote_UpdateDeviceList {
        ::std::default::Default::default()
    }

    // repeated .CHIDDeviceInfo devices = 1;


    pub fn get_devices(&self) -> &[CHIDDeviceInfo] {
        &self.devices
    }
    pub fn clear_devices(&mut self) {
        self.devices.clear();
    }

    // Param is passed by value, moved
    pub fn set_devices(&mut self, v: ::protobuf::RepeatedField<CHIDDeviceInfo>) {
        self.devices = v;
    }

    // Mutable pointer to the field.
    pub fn mut_devices(&mut self) -> &mut ::protobuf::RepeatedField<CHIDDeviceInfo> {
        &mut self.devices
    }

    // Take field
    pub fn take_devices(&mut self) -> ::protobuf::RepeatedField<CHIDDeviceInfo> {
        ::std::mem::replace(&mut self.devices, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for CHIDMessageFromRemote_UpdateDeviceList {
    fn is_initialized(&self) -> bool {
        for v in &self.devices {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.devices)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.devices {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.devices {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageFromRemote_UpdateDeviceList {
        CHIDMessageFromRemote_UpdateDeviceList::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CHIDDeviceInfo>>(
                "devices",
                |m: &CHIDMessageFromRemote_UpdateDeviceList| { &m.devices },
                |m: &mut CHIDMessageFromRemote_UpdateDeviceList| { &mut m.devices },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageFromRemote_UpdateDeviceList>(
                "CHIDMessageFromRemote.UpdateDeviceList",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageFromRemote_UpdateDeviceList {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageFromRemote_UpdateDeviceList> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageFromRemote_UpdateDeviceList::new)
    }
}

impl ::protobuf::Clear for CHIDMessageFromRemote_UpdateDeviceList {
    fn clear(&mut self) {
        self.devices.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageFromRemote_UpdateDeviceList {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageFromRemote_UpdateDeviceList {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageFromRemote_RequestResponse {
    // message fields
    request_id: ::std::option::Option<u32>,
    result: ::std::option::Option<i32>,
    data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageFromRemote_RequestResponse {
    fn default() -> &'a CHIDMessageFromRemote_RequestResponse {
        <CHIDMessageFromRemote_RequestResponse as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageFromRemote_RequestResponse {
    pub fn new() -> CHIDMessageFromRemote_RequestResponse {
        ::std::default::Default::default()
    }

    // optional uint32 request_id = 1;


    pub fn get_request_id(&self) -> u32 {
        self.request_id.unwrap_or(0)
    }
    pub fn clear_request_id(&mut self) {
        self.request_id = ::std::option::Option::None;
    }

    pub fn has_request_id(&self) -> bool {
        self.request_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_request_id(&mut self, v: u32) {
        self.request_id = ::std::option::Option::Some(v);
    }

    // optional int32 result = 2;


    pub fn get_result(&self) -> i32 {
        self.result.unwrap_or(0)
    }
    pub fn clear_result(&mut self) {
        self.result = ::std::option::Option::None;
    }

    pub fn has_result(&self) -> bool {
        self.result.is_some()
    }

    // Param is passed by value, moved
    pub fn set_result(&mut self, v: i32) {
        self.result = ::std::option::Option::Some(v);
    }

    // optional bytes data = 3;


    pub fn get_data(&self) -> &[u8] {
        match self.data.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_data(&mut self) {
        self.data.clear();
    }

    pub fn has_data(&self) -> bool {
        self.data.is_some()
    }

    // Param is passed by value, moved
    pub fn set_data(&mut self, v: ::std::vec::Vec<u8>) {
        self.data = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_data(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.data.is_none() {
            self.data.set_default();
        }
        self.data.as_mut().unwrap()
    }

    // Take field
    pub fn take_data(&mut self) -> ::std::vec::Vec<u8> {
        self.data.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for CHIDMessageFromRemote_RequestResponse {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.request_id = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.result = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.data)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.request_id {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.result {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.data.as_ref() {
            my_size += ::protobuf::rt::bytes_size(3, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.request_id {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.result {
            os.write_int32(2, v)?;
        }
        if let Some(ref v) = self.data.as_ref() {
            os.write_bytes(3, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageFromRemote_RequestResponse {
        CHIDMessageFromRemote_RequestResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "request_id",
                |m: &CHIDMessageFromRemote_RequestResponse| { &m.request_id },
                |m: &mut CHIDMessageFromRemote_RequestResponse| { &mut m.request_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "result",
                |m: &CHIDMessageFromRemote_RequestResponse| { &m.result },
                |m: &mut CHIDMessageFromRemote_RequestResponse| { &mut m.result },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "data",
                |m: &CHIDMessageFromRemote_RequestResponse| { &m.data },
                |m: &mut CHIDMessageFromRemote_RequestResponse| { &mut m.data },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageFromRemote_RequestResponse>(
                "CHIDMessageFromRemote.RequestResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageFromRemote_RequestResponse {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageFromRemote_RequestResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageFromRemote_RequestResponse::new)
    }
}

impl ::protobuf::Clear for CHIDMessageFromRemote_RequestResponse {
    fn clear(&mut self) {
        self.request_id = ::std::option::Option::None;
        self.result = ::std::option::Option::None;
        self.data.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageFromRemote_RequestResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageFromRemote_RequestResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageFromRemote_DeviceInputReports {
    // message fields
    pub device_reports: ::protobuf::RepeatedField<CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageFromRemote_DeviceInputReports {
    fn default() -> &'a CHIDMessageFromRemote_DeviceInputReports {
        <CHIDMessageFromRemote_DeviceInputReports as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageFromRemote_DeviceInputReports {
    pub fn new() -> CHIDMessageFromRemote_DeviceInputReports {
        ::std::default::Default::default()
    }

    // repeated .CHIDMessageFromRemote.DeviceInputReports.DeviceInputReport device_reports = 1;


    pub fn get_device_reports(&self) -> &[CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport] {
        &self.device_reports
    }
    pub fn clear_device_reports(&mut self) {
        self.device_reports.clear();
    }

    // Param is passed by value, moved
    pub fn set_device_reports(&mut self, v: ::protobuf::RepeatedField<CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport>) {
        self.device_reports = v;
    }

    // Mutable pointer to the field.
    pub fn mut_device_reports(&mut self) -> &mut ::protobuf::RepeatedField<CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport> {
        &mut self.device_reports
    }

    // Take field
    pub fn take_device_reports(&mut self) -> ::protobuf::RepeatedField<CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport> {
        ::std::mem::replace(&mut self.device_reports, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for CHIDMessageFromRemote_DeviceInputReports {
    fn is_initialized(&self) -> bool {
        for v in &self.device_reports {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.device_reports)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.device_reports {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.device_reports {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageFromRemote_DeviceInputReports {
        CHIDMessageFromRemote_DeviceInputReports::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport>>(
                "device_reports",
                |m: &CHIDMessageFromRemote_DeviceInputReports| { &m.device_reports },
                |m: &mut CHIDMessageFromRemote_DeviceInputReports| { &mut m.device_reports },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageFromRemote_DeviceInputReports>(
                "CHIDMessageFromRemote.DeviceInputReports",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageFromRemote_DeviceInputReports {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageFromRemote_DeviceInputReports> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageFromRemote_DeviceInputReports::new)
    }
}

impl ::protobuf::Clear for CHIDMessageFromRemote_DeviceInputReports {
    fn clear(&mut self) {
        self.device_reports.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageFromRemote_DeviceInputReports {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageFromRemote_DeviceInputReports {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport {
    // message fields
    device: ::std::option::Option<u32>,
    pub reports: ::protobuf::RepeatedField<CHIDDeviceInputReport>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport {
    fn default() -> &'a CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport {
        <CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport {
    pub fn new() -> CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport {
        ::std::default::Default::default()
    }

    // optional uint32 device = 1;


    pub fn get_device(&self) -> u32 {
        self.device.unwrap_or(0)
    }
    pub fn clear_device(&mut self) {
        self.device = ::std::option::Option::None;
    }

    pub fn has_device(&self) -> bool {
        self.device.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device(&mut self, v: u32) {
        self.device = ::std::option::Option::Some(v);
    }

    // repeated .CHIDDeviceInputReport reports = 2;


    pub fn get_reports(&self) -> &[CHIDDeviceInputReport] {
        &self.reports
    }
    pub fn clear_reports(&mut self) {
        self.reports.clear();
    }

    // Param is passed by value, moved
    pub fn set_reports(&mut self, v: ::protobuf::RepeatedField<CHIDDeviceInputReport>) {
        self.reports = v;
    }

    // Mutable pointer to the field.
    pub fn mut_reports(&mut self) -> &mut ::protobuf::RepeatedField<CHIDDeviceInputReport> {
        &mut self.reports
    }

    // Take field
    pub fn take_reports(&mut self) -> ::protobuf::RepeatedField<CHIDDeviceInputReport> {
        ::std::mem::replace(&mut self.reports, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport {
    fn is_initialized(&self) -> bool {
        for v in &self.reports {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.device = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.reports)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.device {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.reports {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.device {
            os.write_uint32(1, v)?;
        }
        for v in &self.reports {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport {
        CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "device",
                |m: &CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport| { &m.device },
                |m: &mut CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport| { &mut m.device },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CHIDDeviceInputReport>>(
                "reports",
                |m: &CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport| { &m.reports },
                |m: &mut CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport| { &mut m.reports },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport>(
                "CHIDMessageFromRemote.DeviceInputReports.DeviceInputReport",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport::new)
    }
}

impl ::protobuf::Clear for CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport {
    fn clear(&mut self) {
        self.device = ::std::option::Option::None;
        self.reports.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageFromRemote_DeviceInputReports_DeviceInputReport {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageFromRemote_CloseDevice {
    // message fields
    device: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageFromRemote_CloseDevice {
    fn default() -> &'a CHIDMessageFromRemote_CloseDevice {
        <CHIDMessageFromRemote_CloseDevice as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageFromRemote_CloseDevice {
    pub fn new() -> CHIDMessageFromRemote_CloseDevice {
        ::std::default::Default::default()
    }

    // optional uint32 device = 1;


    pub fn get_device(&self) -> u32 {
        self.device.unwrap_or(0)
    }
    pub fn clear_device(&mut self) {
        self.device = ::std::option::Option::None;
    }

    pub fn has_device(&self) -> bool {
        self.device.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device(&mut self, v: u32) {
        self.device = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CHIDMessageFromRemote_CloseDevice {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.device = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.device {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.device {
            os.write_uint32(1, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageFromRemote_CloseDevice {
        CHIDMessageFromRemote_CloseDevice::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "device",
                |m: &CHIDMessageFromRemote_CloseDevice| { &m.device },
                |m: &mut CHIDMessageFromRemote_CloseDevice| { &mut m.device },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageFromRemote_CloseDevice>(
                "CHIDMessageFromRemote.CloseDevice",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageFromRemote_CloseDevice {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageFromRemote_CloseDevice> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageFromRemote_CloseDevice::new)
    }
}

impl ::protobuf::Clear for CHIDMessageFromRemote_CloseDevice {
    fn clear(&mut self) {
        self.device = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageFromRemote_CloseDevice {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageFromRemote_CloseDevice {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CHIDMessageFromRemote_CloseAllDevices {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CHIDMessageFromRemote_CloseAllDevices {
    fn default() -> &'a CHIDMessageFromRemote_CloseAllDevices {
        <CHIDMessageFromRemote_CloseAllDevices as ::protobuf::Message>::default_instance()
    }
}

impl CHIDMessageFromRemote_CloseAllDevices {
    pub fn new() -> CHIDMessageFromRemote_CloseAllDevices {
        ::std::default::Default::default()
    }
}

impl ::protobuf::Message for CHIDMessageFromRemote_CloseAllDevices {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CHIDMessageFromRemote_CloseAllDevices {
        CHIDMessageFromRemote_CloseAllDevices::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let fields = ::std::vec::Vec::new();
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CHIDMessageFromRemote_CloseAllDevices>(
                "CHIDMessageFromRemote.CloseAllDevices",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CHIDMessageFromRemote_CloseAllDevices {
        static instance: ::protobuf::rt::LazyV2<CHIDMessageFromRemote_CloseAllDevices> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CHIDMessageFromRemote_CloseAllDevices::new)
    }
}

impl ::protobuf::Clear for CHIDMessageFromRemote_CloseAllDevices {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CHIDMessageFromRemote_CloseAllDevices {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CHIDMessageFromRemote_CloseAllDevices {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum EHIDDeviceLocation {
    k_EDeviceLocationLocal = 0,
    k_EDeviceLocationRemote = 2,
    k_EDeviceLocationAny = 3,
}

impl ::protobuf::ProtobufEnum for EHIDDeviceLocation {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<EHIDDeviceLocation> {
        match value {
            0 => ::std::option::Option::Some(EHIDDeviceLocation::k_EDeviceLocationLocal),
            2 => ::std::option::Option::Some(EHIDDeviceLocation::k_EDeviceLocationRemote),
            3 => ::std::option::Option::Some(EHIDDeviceLocation::k_EDeviceLocationAny),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [EHIDDeviceLocation] = &[
            EHIDDeviceLocation::k_EDeviceLocationLocal,
            EHIDDeviceLocation::k_EDeviceLocationRemote,
            EHIDDeviceLocation::k_EDeviceLocationAny,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<EHIDDeviceLocation>("EHIDDeviceLocation", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for EHIDDeviceLocation {
}

impl ::std::default::Default for EHIDDeviceLocation {
    fn default() -> Self {
        EHIDDeviceLocation::k_EDeviceLocationLocal
    }
}

impl ::protobuf::reflect::ProtobufValue for EHIDDeviceLocation {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum EHIDDeviceDisconnectMethod {
    k_EDeviceDisconnectMethodUnknown = 0,
    k_EDeviceDisconnectMethodBluetooth = 1,
    k_EDeviceDisconnectMethodFeatureReport = 2,
    k_EDeviceDisconnectMethodOutputReport = 3,
}

impl ::protobuf::ProtobufEnum for EHIDDeviceDisconnectMethod {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<EHIDDeviceDisconnectMethod> {
        match value {
            0 => ::std::option::Option::Some(EHIDDeviceDisconnectMethod::k_EDeviceDisconnectMethodUnknown),
            1 => ::std::option::Option::Some(EHIDDeviceDisconnectMethod::k_EDeviceDisconnectMethodBluetooth),
            2 => ::std::option::Option::Some(EHIDDeviceDisconnectMethod::k_EDeviceDisconnectMethodFeatureReport),
            3 => ::std::option::Option::Some(EHIDDeviceDisconnectMethod::k_EDeviceDisconnectMethodOutputReport),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [EHIDDeviceDisconnectMethod] = &[
            EHIDDeviceDisconnectMethod::k_EDeviceDisconnectMethodUnknown,
            EHIDDeviceDisconnectMethod::k_EDeviceDisconnectMethodBluetooth,
            EHIDDeviceDisconnectMethod::k_EDeviceDisconnectMethodFeatureReport,
            EHIDDeviceDisconnectMethod::k_EDeviceDisconnectMethodOutputReport,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<EHIDDeviceDisconnectMethod>("EHIDDeviceDisconnectMethod", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for EHIDDeviceDisconnectMethod {
}

impl ::std::default::Default for EHIDDeviceDisconnectMethod {
    fn default() -> Self {
        EHIDDeviceDisconnectMethod::k_EDeviceDisconnectMethodUnknown
    }
}

impl ::protobuf::reflect::ProtobufValue for EHIDDeviceDisconnectMethod {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x1esteammessages_hiddevices.proto\"\xc5\x05\n\x0eCHIDDeviceInfo\x12G\
    \n\x08location\x18\x01\x20\x01(\x0e2\x13.EHIDDeviceLocation:\x16k_EDevic\
    eLocationLocalR\x08location\x12\x12\n\x04path\x18\x02\x20\x01(\tR\x04pat\
    h\x12\x1b\n\tvendor_id\x18\x03\x20\x01(\rR\x08vendorId\x12\x1d\n\nproduc\
    t_id\x18\x04\x20\x01(\rR\tproductId\x12#\n\rserial_number\x18\x05\x20\
    \x01(\tR\x0cserialNumber\x12%\n\x0erelease_number\x18\x06\x20\x01(\rR\rr\
    eleaseNumber\x12/\n\x13manufacturer_string\x18\x07\x20\x01(\tR\x12manufa\
    cturerString\x12%\n\x0eproduct_string\x18\x08\x20\x01(\tR\rproductString\
    \x12\x1d\n\nusage_page\x18\t\x20\x01(\rR\tusagePage\x12\x14\n\x05usage\
    \x18\n\x20\x01(\rR\x05usage\x12-\n\x10interface_number\x18\x0b\x20\x01(\
    \x05:\x02-1R\x0finterfaceNumber\x12\x1a\n\x06ostype\x18\x0c\x20\x01(\x05\
    :\x02-1R\x06ostype\x12,\n\x12is_generic_gamepad\x18\r\x20\x01(\x08R\x10i\
    sGenericGamepad\x12.\n\x13is_generic_joystick\x18\x0e\x20\x01(\x08R\x11i\
    sGenericJoystick\x12\x1b\n\tcaps_bits\x18\x0f\x20\x01(\rR\x08capsBits\
    \x12\x1d\n\nsession_id\x18\x10\x20\x01(\rR\tsessionId\x12+\n\x0feControl\
    lerType\x18\x11\x20\x01(\r:\x010R\x0feControllerType\x12/\n\x10is_xinput\
    _device\x18\x12\x20\x01(\x08:\x05falseR\x0eisXinputDevice\"\xb1\x01\n\
    \x15CHIDDeviceInputReport\x12\x1f\n\x0bfull_report\x18\x01\x20\x01(\x0cR\
    \nfullReport\x12!\n\x0cdelta_report\x18\x02\x20\x01(\x0cR\x0bdeltaReport\
    \x12*\n\x11delta_report_size\x18\x03\x20\x01(\rR\x0fdeltaReportSize\x12(\
    \n\x10delta_report_crc\x18\x04\x20\x01(\rR\x0edeltaReportCrc\"\x93\x10\n\
    \x13CHIDMessageToRemote\x12\x1d\n\nrequest_id\x18\x01\x20\x01(\rR\treque\
    stId\x12B\n\x0bdevice_open\x18\x02\x20\x01(\x0b2\x1f.CHIDMessageToRemote\
    .DeviceOpenH\0R\ndeviceOpen\x12E\n\x0cdevice_close\x18\x03\x20\x01(\x0b2\
    \x20.CHIDMessageToRemote.DeviceCloseH\0R\x0bdeviceClose\x12E\n\x0cdevice\
    _write\x18\x04\x20\x01(\x0b2\x20.CHIDMessageToRemote.DeviceWriteH\0R\x0b\
    deviceWrite\x12B\n\x0bdevice_read\x18\x05\x20\x01(\x0b2\x1f.CHIDMessageT\
    oRemote.DeviceReadH\0R\ndeviceRead\x12k\n\x1adevice_send_feature_report\
    \x18\x06\x20\x01(\x0b2,.CHIDMessageToRemote.DeviceSendFeatureReportH\0R\
    \x17deviceSendFeatureReport\x12h\n\x19device_get_feature_report\x18\x07\
    \x20\x01(\x0b2+.CHIDMessageToRemote.DeviceGetFeatureReportH\0R\x16device\
    GetFeatureReport\x12e\n\x18device_get_vendor_string\x18\x08\x20\x01(\x0b\
    2*.CHIDMessageToRemote.DeviceGetVendorStringH\0R\x15deviceGetVendorStrin\
    g\x12h\n\x19device_get_product_string\x18\t\x20\x01(\x0b2+.CHIDMessageTo\
    Remote.DeviceGetProductStringH\0R\x16deviceGetProductString\x12x\n\x1fde\
    vice_get_serial_number_string\x18\n\x20\x01(\x0b20.CHIDMessageToRemote.D\
    eviceGetSerialNumberStringH\0R\x1bdeviceGetSerialNumberString\x12k\n\x1a\
    device_start_input_reports\x18\x0b\x20\x01(\x0b2,.CHIDMessageToRemote.De\
    viceStartInputReportsH\0R\x17deviceStartInputReports\x12k\n\x1adevice_re\
    quest_full_report\x18\x0c\x20\x01(\x0b2,.CHIDMessageToRemote.DeviceReque\
    stFullReportH\0R\x17deviceRequestFullReport\x12T\n\x11device_disconnect\
    \x18\r\x20\x01(\x0b2%.CHIDMessageToRemote.DeviceDisconnectH\0R\x10device\
    Disconnect\x1a1\n\nDeviceOpen\x12#\n\x04info\x18\x01\x20\x01(\x0b2\x0f.C\
    HIDDeviceInfoR\x04info\x1a%\n\x0bDeviceClose\x12\x16\n\x06device\x18\x01\
    \x20\x01(\rR\x06device\x1a9\n\x0bDeviceWrite\x12\x16\n\x06device\x18\x01\
    \x20\x01(\rR\x06device\x12\x12\n\x04data\x18\x02\x20\x01(\x0cR\x04data\
    \x1a[\n\nDeviceRead\x12\x16\n\x06device\x18\x01\x20\x01(\rR\x06device\
    \x12\x16\n\x06length\x18\x02\x20\x01(\rR\x06length\x12\x1d\n\ntimeout_ms\
    \x18\x03\x20\x01(\x05R\ttimeoutMs\x1aE\n\x17DeviceSendFeatureReport\x12\
    \x16\n\x06device\x18\x01\x20\x01(\rR\x06device\x12\x12\n\x04data\x18\x02\
    \x20\x01(\x0cR\x04data\x1am\n\x16DeviceGetFeatureReport\x12\x16\n\x06dev\
    ice\x18\x01\x20\x01(\rR\x06device\x12#\n\rreport_number\x18\x02\x20\x01(\
    \x0cR\x0creportNumber\x12\x16\n\x06length\x18\x03\x20\x01(\rR\x06length\
    \x1a/\n\x15DeviceGetVendorString\x12\x16\n\x06device\x18\x01\x20\x01(\rR\
    \x06device\x1a0\n\x16DeviceGetProductString\x12\x16\n\x06device\x18\x01\
    \x20\x01(\rR\x06device\x1a5\n\x1bDeviceGetSerialNumberString\x12\x16\n\
    \x06device\x18\x01\x20\x01(\rR\x06device\x1aI\n\x17DeviceStartInputRepor\
    ts\x12\x16\n\x06device\x18\x01\x20\x01(\rR\x06device\x12\x16\n\x06length\
    \x18\x02\x20\x01(\rR\x06length\x1a1\n\x17DeviceRequestFullReport\x12\x16\
    \n\x06device\x18\x01\x20\x01(\rR\x06device\x1a\xa9\x01\n\x10DeviceDiscon\
    nect\x12\x16\n\x06device\x18\x01\x20\x01(\rR\x06device\x12i\n\x10disconn\
    ectMethod\x18\x02\x20\x01(\x0e2\x1b.EHIDDeviceDisconnectMethod:\x20k_EDe\
    viceDisconnectMethodUnknownR\x10disconnectMethod\x12\x12\n\x04data\x18\
    \x03\x20\x01(\x0cR\x04dataB\t\n\x07command\"\xd8\x06\n\x15CHIDMessageFro\
    mRemote\x12W\n\x12update_device_list\x18\x01\x20\x01(\x0b2'.CHIDMessageF\
    romRemote.UpdateDeviceListH\0R\x10updateDeviceList\x12D\n\x08response\
    \x18\x02\x20\x01(\x0b2&.CHIDMessageFromRemote.RequestResponseH\0R\x08res\
    ponse\x12E\n\x07reports\x18\x03\x20\x01(\x0b2).CHIDMessageFromRemote.Dev\
    iceInputReportsH\0R\x07reports\x12G\n\x0cclose_device\x18\x04\x20\x01(\
    \x0b2\".CHIDMessageFromRemote.CloseDeviceH\0R\x0bcloseDevice\x12T\n\x11c\
    lose_all_devices\x18\x05\x20\x01(\x0b2&.CHIDMessageFromRemote.CloseAllDe\
    vicesH\0R\x0fcloseAllDevices\x1a=\n\x10UpdateDeviceList\x12)\n\x07device\
    s\x18\x01\x20\x03(\x0b2\x0f.CHIDDeviceInfoR\x07devices\x1a\\\n\x0fReques\
    tResponse\x12\x1d\n\nrequest_id\x18\x01\x20\x01(\rR\trequestId\x12\x16\n\
    \x06result\x18\x02\x20\x01(\x05R\x06result\x12\x12\n\x04data\x18\x03\x20\
    \x01(\x0cR\x04data\x1a\xd7\x01\n\x12DeviceInputReports\x12b\n\x0edevice_\
    reports\x18\x01\x20\x03(\x0b2;.CHIDMessageFromRemote.DeviceInputReports.\
    DeviceInputReportR\rdeviceReports\x1a]\n\x11DeviceInputReport\x12\x16\n\
    \x06device\x18\x01\x20\x01(\rR\x06device\x120\n\x07reports\x18\x02\x20\
    \x03(\x0b2\x16.CHIDDeviceInputReportR\x07reports\x1a%\n\x0bCloseDevice\
    \x12\x16\n\x06device\x18\x01\x20\x01(\rR\x06device\x1a\x11\n\x0fCloseAll\
    DevicesB\t\n\x07command*g\n\x12EHIDDeviceLocation\x12\x1a\n\x16k_EDevice\
    LocationLocal\x10\0\x12\x1b\n\x17k_EDeviceLocationRemote\x10\x02\x12\x18\
    \n\x14k_EDeviceLocationAny\x10\x03*\xc1\x01\n\x1aEHIDDeviceDisconnectMet\
    hod\x12$\n\x20k_EDeviceDisconnectMethodUnknown\x10\0\x12&\n\"k_EDeviceDi\
    sconnectMethodBluetooth\x10\x01\x12*\n&k_EDeviceDisconnectMethodFeatureR\
    eport\x10\x02\x12)\n%k_EDeviceDisconnectMethodOutputReport\x10\x03B\x05H\
    \x01\x80\x01\0J\xe1/\n\x07\x12\x05\0\0\x9a\x01\x01\n\x08\n\x01\x08\x12\
    \x03\0\0\x1c\n\t\n\x02\x08\t\x12\x03\0\0\x1c\n\x08\n\x01\x08\x12\x03\x01\
    \0#\n\t\n\x02\x08\x10\x12\x03\x01\0#\n\n\n\x02\x05\0\x12\x04\x03\0\x07\
    \x01\n\n\n\x03\x05\0\x01\x12\x03\x03\x05\x17\n\x0b\n\x04\x05\0\x02\0\x12\
    \x03\x04\x08#\n\x0c\n\x05\x05\0\x02\0\x01\x12\x03\x04\x08\x1e\n\x0c\n\
    \x05\x05\0\x02\0\x02\x12\x03\x04!\"\n\x0b\n\x04\x05\0\x02\x01\x12\x03\
    \x05\x08$\n\x0c\n\x05\x05\0\x02\x01\x01\x12\x03\x05\x08\x1f\n\x0c\n\x05\
    \x05\0\x02\x01\x02\x12\x03\x05\"#\n\x0b\n\x04\x05\0\x02\x02\x12\x03\x06\
    \x08!\n\x0c\n\x05\x05\0\x02\x02\x01\x12\x03\x06\x08\x1c\n\x0c\n\x05\x05\
    \0\x02\x02\x02\x12\x03\x06\x1f\x20\n\n\n\x02\x05\x01\x12\x04\t\0\x0e\x01\
    \n\n\n\x03\x05\x01\x01\x12\x03\t\x05\x1f\n\x0b\n\x04\x05\x01\x02\0\x12\
    \x03\n\x08-\n\x0c\n\x05\x05\x01\x02\0\x01\x12\x03\n\x08(\n\x0c\n\x05\x05\
    \x01\x02\0\x02\x12\x03\n+,\n\x0b\n\x04\x05\x01\x02\x01\x12\x03\x0b\x08/\
    \n\x0c\n\x05\x05\x01\x02\x01\x01\x12\x03\x0b\x08*\n\x0c\n\x05\x05\x01\
    \x02\x01\x02\x12\x03\x0b-.\n\x0b\n\x04\x05\x01\x02\x02\x12\x03\x0c\x083\
    \n\x0c\n\x05\x05\x01\x02\x02\x01\x12\x03\x0c\x08.\n\x0c\n\x05\x05\x01\
    \x02\x02\x02\x12\x03\x0c12\n\x0b\n\x04\x05\x01\x02\x03\x12\x03\r\x082\n\
    \x0c\n\x05\x05\x01\x02\x03\x01\x12\x03\r\x08-\n\x0c\n\x05\x05\x01\x02\
    \x03\x02\x12\x03\r01\n\n\n\x02\x04\0\x12\x04\x10\0#\x01\n\n\n\x03\x04\0\
    \x01\x12\x03\x10\x08\x16\n\x0b\n\x04\x04\0\x02\0\x12\x03\x11\x08U\n\x0c\
    \n\x05\x04\0\x02\0\x04\x12\x03\x11\x08\x10\n\x0c\n\x05\x04\0\x02\0\x06\
    \x12\x03\x11\x11$\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x11%-\n\x0c\n\x05\
    \x04\0\x02\0\x03\x12\x03\x1101\n\x0c\n\x05\x04\0\x02\0\x08\x12\x03\x112T\
    \n\x0c\n\x05\x04\0\x02\0\x07\x12\x03\x11=S\n\x0b\n\x04\x04\0\x02\x01\x12\
    \x03\x12\x08!\n\x0c\n\x05\x04\0\x02\x01\x04\x12\x03\x12\x08\x10\n\x0c\n\
    \x05\x04\0\x02\x01\x05\x12\x03\x12\x11\x17\n\x0c\n\x05\x04\0\x02\x01\x01\
    \x12\x03\x12\x18\x1c\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03\x12\x1f\x20\n\
    \x0b\n\x04\x04\0\x02\x02\x12\x03\x13\x08&\n\x0c\n\x05\x04\0\x02\x02\x04\
    \x12\x03\x13\x08\x10\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03\x13\x11\x17\n\
    \x0c\n\x05\x04\0\x02\x02\x01\x12\x03\x13\x18!\n\x0c\n\x05\x04\0\x02\x02\
    \x03\x12\x03\x13$%\n\x0b\n\x04\x04\0\x02\x03\x12\x03\x14\x08'\n\x0c\n\
    \x05\x04\0\x02\x03\x04\x12\x03\x14\x08\x10\n\x0c\n\x05\x04\0\x02\x03\x05\
    \x12\x03\x14\x11\x17\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03\x14\x18\"\n\
    \x0c\n\x05\x04\0\x02\x03\x03\x12\x03\x14%&\n\x0b\n\x04\x04\0\x02\x04\x12\
    \x03\x15\x08*\n\x0c\n\x05\x04\0\x02\x04\x04\x12\x03\x15\x08\x10\n\x0c\n\
    \x05\x04\0\x02\x04\x05\x12\x03\x15\x11\x17\n\x0c\n\x05\x04\0\x02\x04\x01\
    \x12\x03\x15\x18%\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x03\x15()\n\x0b\n\
    \x04\x04\0\x02\x05\x12\x03\x16\x08+\n\x0c\n\x05\x04\0\x02\x05\x04\x12\
    \x03\x16\x08\x10\n\x0c\n\x05\x04\0\x02\x05\x05\x12\x03\x16\x11\x17\n\x0c\
    \n\x05\x04\0\x02\x05\x01\x12\x03\x16\x18&\n\x0c\n\x05\x04\0\x02\x05\x03\
    \x12\x03\x16)*\n\x0b\n\x04\x04\0\x02\x06\x12\x03\x17\x080\n\x0c\n\x05\
    \x04\0\x02\x06\x04\x12\x03\x17\x08\x10\n\x0c\n\x05\x04\0\x02\x06\x05\x12\
    \x03\x17\x11\x17\n\x0c\n\x05\x04\0\x02\x06\x01\x12\x03\x17\x18+\n\x0c\n\
    \x05\x04\0\x02\x06\x03\x12\x03\x17./\n\x0b\n\x04\x04\0\x02\x07\x12\x03\
    \x18\x08+\n\x0c\n\x05\x04\0\x02\x07\x04\x12\x03\x18\x08\x10\n\x0c\n\x05\
    \x04\0\x02\x07\x05\x12\x03\x18\x11\x17\n\x0c\n\x05\x04\0\x02\x07\x01\x12\
    \x03\x18\x18&\n\x0c\n\x05\x04\0\x02\x07\x03\x12\x03\x18)*\n\x0b\n\x04\
    \x04\0\x02\x08\x12\x03\x19\x08'\n\x0c\n\x05\x04\0\x02\x08\x04\x12\x03\
    \x19\x08\x10\n\x0c\n\x05\x04\0\x02\x08\x05\x12\x03\x19\x11\x17\n\x0c\n\
    \x05\x04\0\x02\x08\x01\x12\x03\x19\x18\"\n\x0c\n\x05\x04\0\x02\x08\x03\
    \x12\x03\x19%&\n\x0b\n\x04\x04\0\x02\t\x12\x03\x1a\x08#\n\x0c\n\x05\x04\
    \0\x02\t\x04\x12\x03\x1a\x08\x10\n\x0c\n\x05\x04\0\x02\t\x05\x12\x03\x1a\
    \x11\x17\n\x0c\n\x05\x04\0\x02\t\x01\x12\x03\x1a\x18\x1d\n\x0c\n\x05\x04\
    \0\x02\t\x03\x12\x03\x1a\x20\"\n\x0b\n\x04\x04\0\x02\n\x12\x03\x1b\x08<\
    \n\x0c\n\x05\x04\0\x02\n\x04\x12\x03\x1b\x08\x10\n\x0c\n\x05\x04\0\x02\n\
    \x05\x12\x03\x1b\x11\x16\n\x0c\n\x05\x04\0\x02\n\x01\x12\x03\x1b\x17'\n\
    \x0c\n\x05\x04\0\x02\n\x03\x12\x03\x1b*,\n\x0c\n\x05\x04\0\x02\n\x08\x12\
    \x03\x1b-;\n\x0c\n\x05\x04\0\x02\n\x07\x12\x03\x1b8:\n\x0b\n\x04\x04\0\
    \x02\x0b\x12\x03\x1c\x082\n\x0c\n\x05\x04\0\x02\x0b\x04\x12\x03\x1c\x08\
    \x10\n\x0c\n\x05\x04\0\x02\x0b\x05\x12\x03\x1c\x11\x16\n\x0c\n\x05\x04\0\
    \x02\x0b\x01\x12\x03\x1c\x17\x1d\n\x0c\n\x05\x04\0\x02\x0b\x03\x12\x03\
    \x1c\x20\"\n\x0c\n\x05\x04\0\x02\x0b\x08\x12\x03\x1c#1\n\x0c\n\x05\x04\0\
    \x02\x0b\x07\x12\x03\x1c.0\n\x0b\n\x04\x04\0\x02\x0c\x12\x03\x1d\x08.\n\
    \x0c\n\x05\x04\0\x02\x0c\x04\x12\x03\x1d\x08\x10\n\x0c\n\x05\x04\0\x02\
    \x0c\x05\x12\x03\x1d\x11\x15\n\x0c\n\x05\x04\0\x02\x0c\x01\x12\x03\x1d\
    \x16(\n\x0c\n\x05\x04\0\x02\x0c\x03\x12\x03\x1d+-\n\x0b\n\x04\x04\0\x02\
    \r\x12\x03\x1e\x08/\n\x0c\n\x05\x04\0\x02\r\x04\x12\x03\x1e\x08\x10\n\
    \x0c\n\x05\x04\0\x02\r\x05\x12\x03\x1e\x11\x15\n\x0c\n\x05\x04\0\x02\r\
    \x01\x12\x03\x1e\x16)\n\x0c\n\x05\x04\0\x02\r\x03\x12\x03\x1e,.\n\x0b\n\
    \x04\x04\0\x02\x0e\x12\x03\x1f\x08'\n\x0c\n\x05\x04\0\x02\x0e\x04\x12\
    \x03\x1f\x08\x10\n\x0c\n\x05\x04\0\x02\x0e\x05\x12\x03\x1f\x11\x17\n\x0c\
    \n\x05\x04\0\x02\x0e\x01\x12\x03\x1f\x18!\n\x0c\n\x05\x04\0\x02\x0e\x03\
    \x12\x03\x1f$&\n\x0b\n\x04\x04\0\x02\x0f\x12\x03\x20\x08(\n\x0c\n\x05\
    \x04\0\x02\x0f\x04\x12\x03\x20\x08\x10\n\x0c\n\x05\x04\0\x02\x0f\x05\x12\
    \x03\x20\x11\x17\n\x0c\n\x05\x04\0\x02\x0f\x01\x12\x03\x20\x18\"\n\x0c\n\
    \x05\x04\0\x02\x0f\x03\x12\x03\x20%'\n\x0b\n\x04\x04\0\x02\x10\x12\x03!\
    \x08;\n\x0c\n\x05\x04\0\x02\x10\x04\x12\x03!\x08\x10\n\x0c\n\x05\x04\0\
    \x02\x10\x05\x12\x03!\x11\x17\n\x0c\n\x05\x04\0\x02\x10\x01\x12\x03!\x18\
    '\n\x0c\n\x05\x04\0\x02\x10\x03\x12\x03!*,\n\x0c\n\x05\x04\0\x02\x10\x08\
    \x12\x03!-:\n\x0c\n\x05\x04\0\x02\x10\x07\x12\x03!89\n\x0b\n\x04\x04\0\
    \x02\x11\x12\x03\"\x08>\n\x0c\n\x05\x04\0\x02\x11\x04\x12\x03\"\x08\x10\
    \n\x0c\n\x05\x04\0\x02\x11\x05\x12\x03\"\x11\x15\n\x0c\n\x05\x04\0\x02\
    \x11\x01\x12\x03\"\x16&\n\x0c\n\x05\x04\0\x02\x11\x03\x12\x03\")+\n\x0c\
    \n\x05\x04\0\x02\x11\x08\x12\x03\",=\n\x0c\n\x05\x04\0\x02\x11\x07\x12\
    \x03\"7<\n\n\n\x02\x04\x01\x12\x04%\0*\x01\n\n\n\x03\x04\x01\x01\x12\x03\
    %\x08\x1d\n\x0b\n\x04\x04\x01\x02\0\x12\x03&\x08'\n\x0c\n\x05\x04\x01\
    \x02\0\x04\x12\x03&\x08\x10\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03&\x11\
    \x16\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03&\x17\"\n\x0c\n\x05\x04\x01\
    \x02\0\x03\x12\x03&%&\n\x0b\n\x04\x04\x01\x02\x01\x12\x03'\x08(\n\x0c\n\
    \x05\x04\x01\x02\x01\x04\x12\x03'\x08\x10\n\x0c\n\x05\x04\x01\x02\x01\
    \x05\x12\x03'\x11\x16\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03'\x17#\n\
    \x0c\n\x05\x04\x01\x02\x01\x03\x12\x03'&'\n\x0b\n\x04\x04\x01\x02\x02\
    \x12\x03(\x08.\n\x0c\n\x05\x04\x01\x02\x02\x04\x12\x03(\x08\x10\n\x0c\n\
    \x05\x04\x01\x02\x02\x05\x12\x03(\x11\x17\n\x0c\n\x05\x04\x01\x02\x02\
    \x01\x12\x03(\x18)\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03(,-\n\x0b\n\
    \x04\x04\x01\x02\x03\x12\x03)\x08-\n\x0c\n\x05\x04\x01\x02\x03\x04\x12\
    \x03)\x08\x10\n\x0c\n\x05\x04\x01\x02\x03\x05\x12\x03)\x11\x17\n\x0c\n\
    \x05\x04\x01\x02\x03\x01\x12\x03)\x18(\n\x0c\n\x05\x04\x01\x02\x03\x03\
    \x12\x03)+,\n\n\n\x02\x04\x02\x12\x04,\0v\x01\n\n\n\x03\x04\x02\x01\x12\
    \x03,\x08\x1b\n\x0c\n\x04\x04\x02\x03\0\x12\x04-\x08/\t\n\x0c\n\x05\x04\
    \x02\x03\0\x01\x12\x03-\x10\x1a\n\r\n\x06\x04\x02\x03\0\x02\0\x12\x03.\
    \x102\n\x0e\n\x07\x04\x02\x03\0\x02\0\x04\x12\x03.\x10\x18\n\x0e\n\x07\
    \x04\x02\x03\0\x02\0\x06\x12\x03.\x19(\n\x0e\n\x07\x04\x02\x03\0\x02\0\
    \x01\x12\x03.)-\n\x0e\n\x07\x04\x02\x03\0\x02\0\x03\x12\x03.01\n\x0c\n\
    \x04\x04\x02\x03\x01\x12\x041\x083\t\n\x0c\n\x05\x04\x02\x03\x01\x01\x12\
    \x031\x10\x1b\n\r\n\x06\x04\x02\x03\x01\x02\0\x12\x032\x10+\n\x0e\n\x07\
    \x04\x02\x03\x01\x02\0\x04\x12\x032\x10\x18\n\x0e\n\x07\x04\x02\x03\x01\
    \x02\0\x05\x12\x032\x19\x1f\n\x0e\n\x07\x04\x02\x03\x01\x02\0\x01\x12\
    \x032\x20&\n\x0e\n\x07\x04\x02\x03\x01\x02\0\x03\x12\x032)*\n\x0c\n\x04\
    \x04\x02\x03\x02\x12\x045\x088\t\n\x0c\n\x05\x04\x02\x03\x02\x01\x12\x03\
    5\x10\x1b\n\r\n\x06\x04\x02\x03\x02\x02\0\x12\x036\x10+\n\x0e\n\x07\x04\
    \x02\x03\x02\x02\0\x04\x12\x036\x10\x18\n\x0e\n\x07\x04\x02\x03\x02\x02\
    \0\x05\x12\x036\x19\x1f\n\x0e\n\x07\x04\x02\x03\x02\x02\0\x01\x12\x036\
    \x20&\n\x0e\n\x07\x04\x02\x03\x02\x02\0\x03\x12\x036)*\n\r\n\x06\x04\x02\
    \x03\x02\x02\x01\x12\x037\x10(\n\x0e\n\x07\x04\x02\x03\x02\x02\x01\x04\
    \x12\x037\x10\x18\n\x0e\n\x07\x04\x02\x03\x02\x02\x01\x05\x12\x037\x19\
    \x1e\n\x0e\n\x07\x04\x02\x03\x02\x02\x01\x01\x12\x037\x1f#\n\x0e\n\x07\
    \x04\x02\x03\x02\x02\x01\x03\x12\x037&'\n\x0c\n\x04\x04\x02\x03\x03\x12\
    \x04:\x08>\t\n\x0c\n\x05\x04\x02\x03\x03\x01\x12\x03:\x10\x1a\n\r\n\x06\
    \x04\x02\x03\x03\x02\0\x12\x03;\x10+\n\x0e\n\x07\x04\x02\x03\x03\x02\0\
    \x04\x12\x03;\x10\x18\n\x0e\n\x07\x04\x02\x03\x03\x02\0\x05\x12\x03;\x19\
    \x1f\n\x0e\n\x07\x04\x02\x03\x03\x02\0\x01\x12\x03;\x20&\n\x0e\n\x07\x04\
    \x02\x03\x03\x02\0\x03\x12\x03;)*\n\r\n\x06\x04\x02\x03\x03\x02\x01\x12\
    \x03<\x10+\n\x0e\n\x07\x04\x02\x03\x03\x02\x01\x04\x12\x03<\x10\x18\n\
    \x0e\n\x07\x04\x02\x03\x03\x02\x01\x05\x12\x03<\x19\x1f\n\x0e\n\x07\x04\
    \x02\x03\x03\x02\x01\x01\x12\x03<\x20&\n\x0e\n\x07\x04\x02\x03\x03\x02\
    \x01\x03\x12\x03<)*\n\r\n\x06\x04\x02\x03\x03\x02\x02\x12\x03=\x10.\n\
    \x0e\n\x07\x04\x02\x03\x03\x02\x02\x04\x12\x03=\x10\x18\n\x0e\n\x07\x04\
    \x02\x03\x03\x02\x02\x05\x12\x03=\x19\x1e\n\x0e\n\x07\x04\x02\x03\x03\
    \x02\x02\x01\x12\x03=\x1f)\n\x0e\n\x07\x04\x02\x03\x03\x02\x02\x03\x12\
    \x03=,-\n\x0c\n\x04\x04\x02\x03\x04\x12\x04@\x08C\t\n\x0c\n\x05\x04\x02\
    \x03\x04\x01\x12\x03@\x10'\n\r\n\x06\x04\x02\x03\x04\x02\0\x12\x03A\x10+\
    \n\x0e\n\x07\x04\x02\x03\x04\x02\0\x04\x12\x03A\x10\x18\n\x0e\n\x07\x04\
    \x02\x03\x04\x02\0\x05\x12\x03A\x19\x1f\n\x0e\n\x07\x04\x02\x03\x04\x02\
    \0\x01\x12\x03A\x20&\n\x0e\n\x07\x04\x02\x03\x04\x02\0\x03\x12\x03A)*\n\
    \r\n\x06\x04\x02\x03\x04\x02\x01\x12\x03B\x10(\n\x0e\n\x07\x04\x02\x03\
    \x04\x02\x01\x04\x12\x03B\x10\x18\n\x0e\n\x07\x04\x02\x03\x04\x02\x01\
    \x05\x12\x03B\x19\x1e\n\x0e\n\x07\x04\x02\x03\x04\x02\x01\x01\x12\x03B\
    \x1f#\n\x0e\n\x07\x04\x02\x03\x04\x02\x01\x03\x12\x03B&'\n\x0c\n\x04\x04\
    \x02\x03\x05\x12\x04E\x08I\t\n\x0c\n\x05\x04\x02\x03\x05\x01\x12\x03E\
    \x10&\n\r\n\x06\x04\x02\x03\x05\x02\0\x12\x03F\x10+\n\x0e\n\x07\x04\x02\
    \x03\x05\x02\0\x04\x12\x03F\x10\x18\n\x0e\n\x07\x04\x02\x03\x05\x02\0\
    \x05\x12\x03F\x19\x1f\n\x0e\n\x07\x04\x02\x03\x05\x02\0\x01\x12\x03F\x20\
    &\n\x0e\n\x07\x04\x02\x03\x05\x02\0\x03\x12\x03F)*\n\r\n\x06\x04\x02\x03\
    \x05\x02\x01\x12\x03G\x101\n\x0e\n\x07\x04\x02\x03\x05\x02\x01\x04\x12\
    \x03G\x10\x18\n\x0e\n\x07\x04\x02\x03\x05\x02\x01\x05\x12\x03G\x19\x1e\n\
    \x0e\n\x07\x04\x02\x03\x05\x02\x01\x01\x12\x03G\x1f,\n\x0e\n\x07\x04\x02\
    \x03\x05\x02\x01\x03\x12\x03G/0\n\r\n\x06\x04\x02\x03\x05\x02\x02\x12\
    \x03H\x10+\n\x0e\n\x07\x04\x02\x03\x05\x02\x02\x04\x12\x03H\x10\x18\n\
    \x0e\n\x07\x04\x02\x03\x05\x02\x02\x05\x12\x03H\x19\x1f\n\x0e\n\x07\x04\
    \x02\x03\x05\x02\x02\x01\x12\x03H\x20&\n\x0e\n\x07\x04\x02\x03\x05\x02\
    \x02\x03\x12\x03H)*\n\x0c\n\x04\x04\x02\x03\x06\x12\x04K\x08M\t\n\x0c\n\
    \x05\x04\x02\x03\x06\x01\x12\x03K\x10%\n\r\n\x06\x04\x02\x03\x06\x02\0\
    \x12\x03L\x10+\n\x0e\n\x07\x04\x02\x03\x06\x02\0\x04\x12\x03L\x10\x18\n\
    \x0e\n\x07\x04\x02\x03\x06\x02\0\x05\x12\x03L\x19\x1f\n\x0e\n\x07\x04\
    \x02\x03\x06\x02\0\x01\x12\x03L\x20&\n\x0e\n\x07\x04\x02\x03\x06\x02\0\
    \x03\x12\x03L)*\n\x0c\n\x04\x04\x02\x03\x07\x12\x04O\x08Q\t\n\x0c\n\x05\
    \x04\x02\x03\x07\x01\x12\x03O\x10&\n\r\n\x06\x04\x02\x03\x07\x02\0\x12\
    \x03P\x10+\n\x0e\n\x07\x04\x02\x03\x07\x02\0\x04\x12\x03P\x10\x18\n\x0e\
    \n\x07\x04\x02\x03\x07\x02\0\x05\x12\x03P\x19\x1f\n\x0e\n\x07\x04\x02\
    \x03\x07\x02\0\x01\x12\x03P\x20&\n\x0e\n\x07\x04\x02\x03\x07\x02\0\x03\
    \x12\x03P)*\n\x0c\n\x04\x04\x02\x03\x08\x12\x04S\x08U\t\n\x0c\n\x05\x04\
    \x02\x03\x08\x01\x12\x03S\x10+\n\r\n\x06\x04\x02\x03\x08\x02\0\x12\x03T\
    \x10+\n\x0e\n\x07\x04\x02\x03\x08\x02\0\x04\x12\x03T\x10\x18\n\x0e\n\x07\
    \x04\x02\x03\x08\x02\0\x05\x12\x03T\x19\x1f\n\x0e\n\x07\x04\x02\x03\x08\
    \x02\0\x01\x12\x03T\x20&\n\x0e\n\x07\x04\x02\x03\x08\x02\0\x03\x12\x03T)\
    *\n\x0c\n\x04\x04\x02\x03\t\x12\x04W\x08Z\t\n\x0c\n\x05\x04\x02\x03\t\
    \x01\x12\x03W\x10'\n\r\n\x06\x04\x02\x03\t\x02\0\x12\x03X\x10+\n\x0e\n\
    \x07\x04\x02\x03\t\x02\0\x04\x12\x03X\x10\x18\n\x0e\n\x07\x04\x02\x03\t\
    \x02\0\x05\x12\x03X\x19\x1f\n\x0e\n\x07\x04\x02\x03\t\x02\0\x01\x12\x03X\
    \x20&\n\x0e\n\x07\x04\x02\x03\t\x02\0\x03\x12\x03X)*\n\r\n\x06\x04\x02\
    \x03\t\x02\x01\x12\x03Y\x10+\n\x0e\n\x07\x04\x02\x03\t\x02\x01\x04\x12\
    \x03Y\x10\x18\n\x0e\n\x07\x04\x02\x03\t\x02\x01\x05\x12\x03Y\x19\x1f\n\
    \x0e\n\x07\x04\x02\x03\t\x02\x01\x01\x12\x03Y\x20&\n\x0e\n\x07\x04\x02\
    \x03\t\x02\x01\x03\x12\x03Y)*\n\x0c\n\x04\x04\x02\x03\n\x12\x04\\\x08^\t\
    \n\x0c\n\x05\x04\x02\x03\n\x01\x12\x03\\\x10'\n\r\n\x06\x04\x02\x03\n\
    \x02\0\x12\x03]\x10+\n\x0e\n\x07\x04\x02\x03\n\x02\0\x04\x12\x03]\x10\
    \x18\n\x0e\n\x07\x04\x02\x03\n\x02\0\x05\x12\x03]\x19\x1f\n\x0e\n\x07\
    \x04\x02\x03\n\x02\0\x01\x12\x03]\x20&\n\x0e\n\x07\x04\x02\x03\n\x02\0\
    \x03\x12\x03])*\n\x0c\n\x04\x04\x02\x03\x0b\x12\x04`\x08d\t\n\x0c\n\x05\
    \x04\x02\x03\x0b\x01\x12\x03`\x10\x20\n\r\n\x06\x04\x02\x03\x0b\x02\0\
    \x12\x03a\x10+\n\x0e\n\x07\x04\x02\x03\x0b\x02\0\x04\x12\x03a\x10\x18\n\
    \x0e\n\x07\x04\x02\x03\x0b\x02\0\x05\x12\x03a\x19\x1f\n\x0e\n\x07\x04\
    \x02\x03\x0b\x02\0\x01\x12\x03a\x20&\n\x0e\n\x07\x04\x02\x03\x0b\x02\0\
    \x03\x12\x03a)*\n\r\n\x06\x04\x02\x03\x0b\x02\x01\x12\x03b\x10w\n\x0e\n\
    \x07\x04\x02\x03\x0b\x02\x01\x04\x12\x03b\x10\x18\n\x0e\n\x07\x04\x02\
    \x03\x0b\x02\x01\x06\x12\x03b\x194\n\x0e\n\x07\x04\x02\x03\x0b\x02\x01\
    \x01\x12\x03b5E\n\x0e\n\x07\x04\x02\x03\x0b\x02\x01\x03\x12\x03bHI\n\x0e\
    \n\x07\x04\x02\x03\x0b\x02\x01\x08\x12\x03bJv\n\x0e\n\x07\x04\x02\x03\
    \x0b\x02\x01\x07\x12\x03bUu\n\r\n\x06\x04\x02\x03\x0b\x02\x02\x12\x03c\
    \x10(\n\x0e\n\x07\x04\x02\x03\x0b\x02\x02\x04\x12\x03c\x10\x18\n\x0e\n\
    \x07\x04\x02\x03\x0b\x02\x02\x05\x12\x03c\x19\x1e\n\x0e\n\x07\x04\x02\
    \x03\x0b\x02\x02\x01\x12\x03c\x1f#\n\x0e\n\x07\x04\x02\x03\x0b\x02\x02\
    \x03\x12\x03c&'\n\x0b\n\x04\x04\x02\x02\0\x12\x03f\x08'\n\x0c\n\x05\x04\
    \x02\x02\0\x04\x12\x03f\x08\x10\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03f\
    \x11\x17\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03f\x18\"\n\x0c\n\x05\x04\
    \x02\x02\0\x03\x12\x03f%&\n\x0c\n\x04\x04\x02\x08\0\x12\x04h\x08u\t\n\
    \x0c\n\x05\x04\x02\x08\0\x01\x12\x03h\x0e\x15\n\x0b\n\x04\x04\x02\x02\
    \x01\x12\x03i\x10@\n\x0c\n\x05\x04\x02\x02\x01\x06\x12\x03i\x10/\n\x0c\n\
    \x05\x04\x02\x02\x01\x01\x12\x03i0;\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\
    \x03i>?\n\x0b\n\x04\x04\x02\x02\x02\x12\x03j\x10B\n\x0c\n\x05\x04\x02\
    \x02\x02\x06\x12\x03j\x100\n\x0c\n\x05\x04\x02\x02\x02\x01\x12\x03j1=\n\
    \x0c\n\x05\x04\x02\x02\x02\x03\x12\x03j@A\n\x0b\n\x04\x04\x02\x02\x03\
    \x12\x03k\x10B\n\x0c\n\x05\x04\x02\x02\x03\x06\x12\x03k\x100\n\x0c\n\x05\
    \x04\x02\x02\x03\x01\x12\x03k1=\n\x0c\n\x05\x04\x02\x02\x03\x03\x12\x03k\
    @A\n\x0b\n\x04\x04\x02\x02\x04\x12\x03l\x10@\n\x0c\n\x05\x04\x02\x02\x04\
    \x06\x12\x03l\x10/\n\x0c\n\x05\x04\x02\x02\x04\x01\x12\x03l0;\n\x0c\n\
    \x05\x04\x02\x02\x04\x03\x12\x03l>?\n\x0b\n\x04\x04\x02\x02\x05\x12\x03m\
    \x10\\\n\x0c\n\x05\x04\x02\x02\x05\x06\x12\x03m\x10<\n\x0c\n\x05\x04\x02\
    \x02\x05\x01\x12\x03m=W\n\x0c\n\x05\x04\x02\x02\x05\x03\x12\x03mZ[\n\x0b\
    \n\x04\x04\x02\x02\x06\x12\x03n\x10Z\n\x0c\n\x05\x04\x02\x02\x06\x06\x12\
    \x03n\x10;\n\x0c\n\x05\x04\x02\x02\x06\x01\x12\x03n<U\n\x0c\n\x05\x04\
    \x02\x02\x06\x03\x12\x03nXY\n\x0b\n\x04\x04\x02\x02\x07\x12\x03o\x10X\n\
    \x0c\n\x05\x04\x02\x02\x07\x06\x12\x03o\x10:\n\x0c\n\x05\x04\x02\x02\x07\
    \x01\x12\x03o;S\n\x0c\n\x05\x04\x02\x02\x07\x03\x12\x03oVW\n\x0b\n\x04\
    \x04\x02\x02\x08\x12\x03p\x10Z\n\x0c\n\x05\x04\x02\x02\x08\x06\x12\x03p\
    \x10;\n\x0c\n\x05\x04\x02\x02\x08\x01\x12\x03p<U\n\x0c\n\x05\x04\x02\x02\
    \x08\x03\x12\x03pXY\n\x0b\n\x04\x04\x02\x02\t\x12\x03q\x10f\n\x0c\n\x05\
    \x04\x02\x02\t\x06\x12\x03q\x10@\n\x0c\n\x05\x04\x02\x02\t\x01\x12\x03qA\
    `\n\x0c\n\x05\x04\x02\x02\t\x03\x12\x03qce\n\x0b\n\x04\x04\x02\x02\n\x12\
    \x03r\x10]\n\x0c\n\x05\x04\x02\x02\n\x06\x12\x03r\x10<\n\x0c\n\x05\x04\
    \x02\x02\n\x01\x12\x03r=W\n\x0c\n\x05\x04\x02\x02\n\x03\x12\x03rZ\\\n\
    \x0b\n\x04\x04\x02\x02\x0b\x12\x03s\x10]\n\x0c\n\x05\x04\x02\x02\x0b\x06\
    \x12\x03s\x10<\n\x0c\n\x05\x04\x02\x02\x0b\x01\x12\x03s=W\n\x0c\n\x05\
    \x04\x02\x02\x0b\x03\x12\x03sZ\\\n\x0b\n\x04\x04\x02\x02\x0c\x12\x03t\
    \x10M\n\x0c\n\x05\x04\x02\x02\x0c\x06\x12\x03t\x105\n\x0c\n\x05\x04\x02\
    \x02\x0c\x01\x12\x03t6G\n\x0c\n\x05\x04\x02\x02\x0c\x03\x12\x03tJL\n\x0b\
    \n\x02\x04\x03\x12\x05x\0\x9a\x01\x01\n\n\n\x03\x04\x03\x01\x12\x03x\x08\
    \x1d\n\x0c\n\x04\x04\x03\x03\0\x12\x04y\x08{\t\n\x0c\n\x05\x04\x03\x03\0\
    \x01\x12\x03y\x10\x20\n\r\n\x06\x04\x03\x03\0\x02\0\x12\x03z\x105\n\x0e\
    \n\x07\x04\x03\x03\0\x02\0\x04\x12\x03z\x10\x18\n\x0e\n\x07\x04\x03\x03\
    \0\x02\0\x06\x12\x03z\x19(\n\x0e\n\x07\x04\x03\x03\0\x02\0\x01\x12\x03z)\
    0\n\x0e\n\x07\x04\x03\x03\0\x02\0\x03\x12\x03z34\n\r\n\x04\x04\x03\x03\
    \x01\x12\x05}\x08\x81\x01\t\n\x0c\n\x05\x04\x03\x03\x01\x01\x12\x03}\x10\
    \x1f\n\r\n\x06\x04\x03\x03\x01\x02\0\x12\x03~\x10/\n\x0e\n\x07\x04\x03\
    \x03\x01\x02\0\x04\x12\x03~\x10\x18\n\x0e\n\x07\x04\x03\x03\x01\x02\0\
    \x05\x12\x03~\x19\x1f\n\x0e\n\x07\x04\x03\x03\x01\x02\0\x01\x12\x03~\x20\
    *\n\x0e\n\x07\x04\x03\x03\x01\x02\0\x03\x12\x03~-.\n\r\n\x06\x04\x03\x03\
    \x01\x02\x01\x12\x03\x7f\x10*\n\x0e\n\x07\x04\x03\x03\x01\x02\x01\x04\
    \x12\x03\x7f\x10\x18\n\x0e\n\x07\x04\x03\x03\x01\x02\x01\x05\x12\x03\x7f\
    \x19\x1e\n\x0e\n\x07\x04\x03\x03\x01\x02\x01\x01\x12\x03\x7f\x1f%\n\x0e\
    \n\x07\x04\x03\x03\x01\x02\x01\x03\x12\x03\x7f()\n\x0e\n\x06\x04\x03\x03\
    \x01\x02\x02\x12\x04\x80\x01\x10(\n\x0f\n\x07\x04\x03\x03\x01\x02\x02\
    \x04\x12\x04\x80\x01\x10\x18\n\x0f\n\x07\x04\x03\x03\x01\x02\x02\x05\x12\
    \x04\x80\x01\x19\x1e\n\x0f\n\x07\x04\x03\x03\x01\x02\x02\x01\x12\x04\x80\
    \x01\x1f#\n\x0f\n\x07\x04\x03\x03\x01\x02\x02\x03\x12\x04\x80\x01&'\n\
    \x0e\n\x04\x04\x03\x03\x02\x12\x06\x83\x01\x08\x8a\x01\t\n\r\n\x05\x04\
    \x03\x03\x02\x01\x12\x04\x83\x01\x10\"\n\x10\n\x06\x04\x03\x03\x02\x03\0\
    \x12\x06\x84\x01\x10\x87\x01\x11\n\x0f\n\x07\x04\x03\x03\x02\x03\0\x01\
    \x12\x04\x84\x01\x18)\n\x10\n\x08\x04\x03\x03\x02\x03\0\x02\0\x12\x04\
    \x85\x01\x183\n\x11\n\t\x04\x03\x03\x02\x03\0\x02\0\x04\x12\x04\x85\x01\
    \x18\x20\n\x11\n\t\x04\x03\x03\x02\x03\0\x02\0\x05\x12\x04\x85\x01!'\n\
    \x11\n\t\x04\x03\x03\x02\x03\0\x02\0\x01\x12\x04\x85\x01(.\n\x11\n\t\x04\
    \x03\x03\x02\x03\0\x02\0\x03\x12\x04\x85\x0112\n\x10\n\x08\x04\x03\x03\
    \x02\x03\0\x02\x01\x12\x04\x86\x01\x18D\n\x11\n\t\x04\x03\x03\x02\x03\0\
    \x02\x01\x04\x12\x04\x86\x01\x18\x20\n\x11\n\t\x04\x03\x03\x02\x03\0\x02\
    \x01\x06\x12\x04\x86\x01!7\n\x11\n\t\x04\x03\x03\x02\x03\0\x02\x01\x01\
    \x12\x04\x86\x018?\n\x11\n\t\x04\x03\x03\x02\x03\0\x02\x01\x03\x12\x04\
    \x86\x01BC\n\x0e\n\x06\x04\x03\x03\x02\x02\0\x12\x04\x89\x01\x10h\n\x0f\
    \n\x07\x04\x03\x03\x02\x02\0\x04\x12\x04\x89\x01\x10\x18\n\x0f\n\x07\x04\
    \x03\x03\x02\x02\0\x06\x12\x04\x89\x01\x19T\n\x0f\n\x07\x04\x03\x03\x02\
    \x02\0\x01\x12\x04\x89\x01Uc\n\x0f\n\x07\x04\x03\x03\x02\x02\0\x03\x12\
    \x04\x89\x01fg\n\x0e\n\x04\x04\x03\x03\x03\x12\x06\x8c\x01\x08\x8e\x01\t\
    \n\r\n\x05\x04\x03\x03\x03\x01\x12\x04\x8c\x01\x10\x1b\n\x0e\n\x06\x04\
    \x03\x03\x03\x02\0\x12\x04\x8d\x01\x10+\n\x0f\n\x07\x04\x03\x03\x03\x02\
    \0\x04\x12\x04\x8d\x01\x10\x18\n\x0f\n\x07\x04\x03\x03\x03\x02\0\x05\x12\
    \x04\x8d\x01\x19\x1f\n\x0f\n\x07\x04\x03\x03\x03\x02\0\x01\x12\x04\x8d\
    \x01\x20&\n\x0f\n\x07\x04\x03\x03\x03\x02\0\x03\x12\x04\x8d\x01)*\n\x0e\
    \n\x04\x04\x03\x03\x04\x12\x06\x90\x01\x08\x91\x01\t\n\r\n\x05\x04\x03\
    \x03\x04\x01\x12\x04\x90\x01\x10\x1f\n\x0e\n\x04\x04\x03\x08\0\x12\x06\
    \x93\x01\x08\x99\x01\t\n\r\n\x05\x04\x03\x08\0\x01\x12\x04\x93\x01\x0e\
    \x15\n\x0c\n\x04\x04\x03\x02\0\x12\x04\x94\x01\x10O\n\r\n\x05\x04\x03\
    \x02\0\x06\x12\x04\x94\x01\x107\n\r\n\x05\x04\x03\x02\0\x01\x12\x04\x94\
    \x018J\n\r\n\x05\x04\x03\x02\0\x03\x12\x04\x94\x01MN\n\x0c\n\x04\x04\x03\
    \x02\x01\x12\x04\x95\x01\x10D\n\r\n\x05\x04\x03\x02\x01\x06\x12\x04\x95\
    \x01\x106\n\r\n\x05\x04\x03\x02\x01\x01\x12\x04\x95\x017?\n\r\n\x05\x04\
    \x03\x02\x01\x03\x12\x04\x95\x01BC\n\x0c\n\x04\x04\x03\x02\x02\x12\x04\
    \x96\x01\x10F\n\r\n\x05\x04\x03\x02\x02\x06\x12\x04\x96\x01\x109\n\r\n\
    \x05\x04\x03\x02\x02\x01\x12\x04\x96\x01:A\n\r\n\x05\x04\x03\x02\x02\x03\
    \x12\x04\x96\x01DE\n\x0c\n\x04\x04\x03\x02\x03\x12\x04\x97\x01\x10D\n\r\
    \n\x05\x04\x03\x02\x03\x06\x12\x04\x97\x01\x102\n\r\n\x05\x04\x03\x02\
    \x03\x01\x12\x04\x97\x013?\n\r\n\x05\x04\x03\x02\x03\x03\x12\x04\x97\x01\
    BC\n\x0c\n\x04\x04\x03\x02\x04\x12\x04\x98\x01\x10M\n\r\n\x05\x04\x03\
    \x02\x04\x06\x12\x04\x98\x01\x106\n\r\n\x05\x04\x03\x02\x04\x01\x12\x04\
    \x98\x017H\n\r\n\x05\x04\x03\x02\x04\x03\x12\x04\x98\x01KL\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}