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_accounthardware.steamclient.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 CAccountHardware_RegisterSteamController_Request {
    // message fields
    serial_number: ::protobuf::SingularField<::std::string::String>,
    controller_code: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string serial_number = 1;


    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 string controller_code = 2;


    pub fn get_controller_code(&self) -> &str {
        match self.controller_code.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_controller_code(&mut self) {
        self.controller_code.clear();
    }

    pub fn has_controller_code(&self) -> bool {
        self.controller_code.is_some()
    }

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

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

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

impl ::protobuf::Message for CAccountHardware_RegisterSteamController_Request {
    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_string_into(wire_type, is, &mut self.serial_number)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.controller_code)?;
                },
                _ => {
                    ::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.serial_number.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.controller_code.as_ref() {
            my_size += ::protobuf::rt::string_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(ref v) = self.serial_number.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.controller_code.as_ref() {
            os.write_string(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() -> CAccountHardware_RegisterSteamController_Request {
        CAccountHardware_RegisterSteamController_Request::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::ProtobufTypeString>(
                "serial_number",
                |m: &CAccountHardware_RegisterSteamController_Request| { &m.serial_number },
                |m: &mut CAccountHardware_RegisterSteamController_Request| { &mut m.serial_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "controller_code",
                |m: &CAccountHardware_RegisterSteamController_Request| { &m.controller_code },
                |m: &mut CAccountHardware_RegisterSteamController_Request| { &mut m.controller_code },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_RegisterSteamController_Request>(
                "CAccountHardware_RegisterSteamController_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

impl ::protobuf::Message for CAccountHardware_RegisterSteamController_Response {
    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() -> CAccountHardware_RegisterSteamController_Response {
        CAccountHardware_RegisterSteamController_Response::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::<CAccountHardware_RegisterSteamController_Response>(
                "CAccountHardware_RegisterSteamController_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountHardware_CompleteSteamControllerRegistration_Request {
    // message fields
    serial_number: ::protobuf::SingularField<::std::string::String>,
    controller_code: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string serial_number = 1;


    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 string controller_code = 2;


    pub fn get_controller_code(&self) -> &str {
        match self.controller_code.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_controller_code(&mut self) {
        self.controller_code.clear();
    }

    pub fn has_controller_code(&self) -> bool {
        self.controller_code.is_some()
    }

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

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

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

impl ::protobuf::Message for CAccountHardware_CompleteSteamControllerRegistration_Request {
    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_string_into(wire_type, is, &mut self.serial_number)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.controller_code)?;
                },
                _ => {
                    ::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.serial_number.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.controller_code.as_ref() {
            my_size += ::protobuf::rt::string_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(ref v) = self.serial_number.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.controller_code.as_ref() {
            os.write_string(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() -> CAccountHardware_CompleteSteamControllerRegistration_Request {
        CAccountHardware_CompleteSteamControllerRegistration_Request::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::ProtobufTypeString>(
                "serial_number",
                |m: &CAccountHardware_CompleteSteamControllerRegistration_Request| { &m.serial_number },
                |m: &mut CAccountHardware_CompleteSteamControllerRegistration_Request| { &mut m.serial_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "controller_code",
                |m: &CAccountHardware_CompleteSteamControllerRegistration_Request| { &m.controller_code },
                |m: &mut CAccountHardware_CompleteSteamControllerRegistration_Request| { &mut m.controller_code },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_CompleteSteamControllerRegistration_Request>(
                "CAccountHardware_CompleteSteamControllerRegistration_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

impl ::protobuf::Message for CAccountHardware_CompleteSteamControllerRegistration_Response {
    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() -> CAccountHardware_CompleteSteamControllerRegistration_Response {
        CAccountHardware_CompleteSteamControllerRegistration_Response::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::<CAccountHardware_CompleteSteamControllerRegistration_Response>(
                "CAccountHardware_CompleteSteamControllerRegistration_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountHardware_QueryAccountsRegisteredToSerial_Request {
    // message fields
    serial_number: ::protobuf::SingularField<::std::string::String>,
    controller_code: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string serial_number = 1;


    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 string controller_code = 2;


    pub fn get_controller_code(&self) -> &str {
        match self.controller_code.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_controller_code(&mut self) {
        self.controller_code.clear();
    }

    pub fn has_controller_code(&self) -> bool {
        self.controller_code.is_some()
    }

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

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

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

impl ::protobuf::Message for CAccountHardware_QueryAccountsRegisteredToSerial_Request {
    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_string_into(wire_type, is, &mut self.serial_number)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.controller_code)?;
                },
                _ => {
                    ::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.serial_number.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.controller_code.as_ref() {
            my_size += ::protobuf::rt::string_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(ref v) = self.serial_number.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.controller_code.as_ref() {
            os.write_string(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() -> CAccountHardware_QueryAccountsRegisteredToSerial_Request {
        CAccountHardware_QueryAccountsRegisteredToSerial_Request::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::ProtobufTypeString>(
                "serial_number",
                |m: &CAccountHardware_QueryAccountsRegisteredToSerial_Request| { &m.serial_number },
                |m: &mut CAccountHardware_QueryAccountsRegisteredToSerial_Request| { &mut m.serial_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "controller_code",
                |m: &CAccountHardware_QueryAccountsRegisteredToSerial_Request| { &m.controller_code },
                |m: &mut CAccountHardware_QueryAccountsRegisteredToSerial_Request| { &mut m.controller_code },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_QueryAccountsRegisteredToSerial_Request>(
                "CAccountHardware_QueryAccountsRegisteredToSerial_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional uint32 accountid = 1;


    pub fn get_accountid(&self) -> u32 {
        self.accountid.unwrap_or(0)
    }
    pub fn clear_accountid(&mut self) {
        self.accountid = ::std::option::Option::None;
    }

    pub fn has_accountid(&self) -> bool {
        self.accountid.is_some()
    }

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

    // optional bool registration_complete = 2;


    pub fn get_registration_complete(&self) -> bool {
        self.registration_complete.unwrap_or(false)
    }
    pub fn clear_registration_complete(&mut self) {
        self.registration_complete = ::std::option::Option::None;
    }

    pub fn has_registration_complete(&self) -> bool {
        self.registration_complete.is_some()
    }

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

impl ::protobuf::Message for CAccountHardware_QueryAccountsRegisteredToSerial_Accounts {
    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.accountid = ::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_bool()?;
                    self.registration_complete = ::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.accountid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.registration_complete {
            my_size += 2;
        }
        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.accountid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.registration_complete {
            os.write_bool(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() -> CAccountHardware_QueryAccountsRegisteredToSerial_Accounts {
        CAccountHardware_QueryAccountsRegisteredToSerial_Accounts::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>(
                "accountid",
                |m: &CAccountHardware_QueryAccountsRegisteredToSerial_Accounts| { &m.accountid },
                |m: &mut CAccountHardware_QueryAccountsRegisteredToSerial_Accounts| { &mut m.accountid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "registration_complete",
                |m: &CAccountHardware_QueryAccountsRegisteredToSerial_Accounts| { &m.registration_complete },
                |m: &mut CAccountHardware_QueryAccountsRegisteredToSerial_Accounts| { &mut m.registration_complete },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_QueryAccountsRegisteredToSerial_Accounts>(
                "CAccountHardware_QueryAccountsRegisteredToSerial_Accounts",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // repeated .CAccountHardware_QueryAccountsRegisteredToSerial_Accounts accounts = 1;


    pub fn get_accounts(&self) -> &[CAccountHardware_QueryAccountsRegisteredToSerial_Accounts] {
        &self.accounts
    }
    pub fn clear_accounts(&mut self) {
        self.accounts.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_accounts(&mut self) -> &mut ::protobuf::RepeatedField<CAccountHardware_QueryAccountsRegisteredToSerial_Accounts> {
        &mut self.accounts
    }

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

impl ::protobuf::Message for CAccountHardware_QueryAccountsRegisteredToSerial_Response {
    fn is_initialized(&self) -> bool {
        for v in &self.accounts {
            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.accounts)?;
                },
                _ => {
                    ::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.accounts {
            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.accounts {
            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() -> CAccountHardware_QueryAccountsRegisteredToSerial_Response {
        CAccountHardware_QueryAccountsRegisteredToSerial_Response::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<CAccountHardware_QueryAccountsRegisteredToSerial_Accounts>>(
                "accounts",
                |m: &CAccountHardware_QueryAccountsRegisteredToSerial_Response| { &m.accounts },
                |m: &mut CAccountHardware_QueryAccountsRegisteredToSerial_Response| { &mut m.accounts },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_QueryAccountsRegisteredToSerial_Response>(
                "CAccountHardware_QueryAccountsRegisteredToSerial_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountHardware_SteamControllerSetConfig_ControllerConfig {
    // message fields
    appidorname: ::protobuf::SingularField<::std::string::String>,
    publishedfileid: ::std::option::Option<u64>,
    templatename: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string appidorname = 1;


    pub fn get_appidorname(&self) -> &str {
        match self.appidorname.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_appidorname(&mut self) {
        self.appidorname.clear();
    }

    pub fn has_appidorname(&self) -> bool {
        self.appidorname.is_some()
    }

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

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

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

    // optional uint64 publishedfileid = 2;


    pub fn get_publishedfileid(&self) -> u64 {
        self.publishedfileid.unwrap_or(0)
    }
    pub fn clear_publishedfileid(&mut self) {
        self.publishedfileid = ::std::option::Option::None;
    }

    pub fn has_publishedfileid(&self) -> bool {
        self.publishedfileid.is_some()
    }

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

    // optional string templatename = 3;


    pub fn get_templatename(&self) -> &str {
        match self.templatename.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_templatename(&mut self) {
        self.templatename.clear();
    }

    pub fn has_templatename(&self) -> bool {
        self.templatename.is_some()
    }

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

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

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

impl ::protobuf::Message for CAccountHardware_SteamControllerSetConfig_ControllerConfig {
    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_string_into(wire_type, is, &mut self.appidorname)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.publishedfileid = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.templatename)?;
                },
                _ => {
                    ::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.appidorname.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.publishedfileid {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.templatename.as_ref() {
            my_size += ::protobuf::rt::string_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(ref v) = self.appidorname.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(v) = self.publishedfileid {
            os.write_uint64(2, v)?;
        }
        if let Some(ref v) = self.templatename.as_ref() {
            os.write_string(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() -> CAccountHardware_SteamControllerSetConfig_ControllerConfig {
        CAccountHardware_SteamControllerSetConfig_ControllerConfig::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::ProtobufTypeString>(
                "appidorname",
                |m: &CAccountHardware_SteamControllerSetConfig_ControllerConfig| { &m.appidorname },
                |m: &mut CAccountHardware_SteamControllerSetConfig_ControllerConfig| { &mut m.appidorname },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "publishedfileid",
                |m: &CAccountHardware_SteamControllerSetConfig_ControllerConfig| { &m.publishedfileid },
                |m: &mut CAccountHardware_SteamControllerSetConfig_ControllerConfig| { &mut m.publishedfileid },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "templatename",
                |m: &CAccountHardware_SteamControllerSetConfig_ControllerConfig| { &m.templatename },
                |m: &mut CAccountHardware_SteamControllerSetConfig_ControllerConfig| { &mut m.templatename },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_SteamControllerSetConfig_ControllerConfig>(
                "CAccountHardware_SteamControllerSetConfig_ControllerConfig",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CAccountHardware_SteamControllerSetConfig_ControllerConfig {
    fn clear(&mut self) {
        self.appidorname.clear();
        self.publishedfileid = ::std::option::Option::None;
        self.templatename.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountHardware_SteamControllerSetConfig_Request {
    // message fields
    serial_number: ::protobuf::SingularField<::std::string::String>,
    controller_code: ::protobuf::SingularField<::std::string::String>,
    accountid: ::std::option::Option<u32>,
    pub configurations: ::protobuf::RepeatedField<CAccountHardware_SteamControllerSetConfig_ControllerConfig>,
    controller_type: ::std::option::Option<i32>,
    only_for_this_serial: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string serial_number = 1;


    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 string controller_code = 2;


    pub fn get_controller_code(&self) -> &str {
        match self.controller_code.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_controller_code(&mut self) {
        self.controller_code.clear();
    }

    pub fn has_controller_code(&self) -> bool {
        self.controller_code.is_some()
    }

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

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

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

    // optional uint32 accountid = 3;


    pub fn get_accountid(&self) -> u32 {
        self.accountid.unwrap_or(0)
    }
    pub fn clear_accountid(&mut self) {
        self.accountid = ::std::option::Option::None;
    }

    pub fn has_accountid(&self) -> bool {
        self.accountid.is_some()
    }

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

    // repeated .CAccountHardware_SteamControllerSetConfig_ControllerConfig configurations = 4;


    pub fn get_configurations(&self) -> &[CAccountHardware_SteamControllerSetConfig_ControllerConfig] {
        &self.configurations
    }
    pub fn clear_configurations(&mut self) {
        self.configurations.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_configurations(&mut self) -> &mut ::protobuf::RepeatedField<CAccountHardware_SteamControllerSetConfig_ControllerConfig> {
        &mut self.configurations
    }

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

    // optional int32 controller_type = 5;


    pub fn get_controller_type(&self) -> i32 {
        self.controller_type.unwrap_or(2i32)
    }
    pub fn clear_controller_type(&mut self) {
        self.controller_type = ::std::option::Option::None;
    }

    pub fn has_controller_type(&self) -> bool {
        self.controller_type.is_some()
    }

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

    // optional bool only_for_this_serial = 6;


    pub fn get_only_for_this_serial(&self) -> bool {
        self.only_for_this_serial.unwrap_or(false)
    }
    pub fn clear_only_for_this_serial(&mut self) {
        self.only_for_this_serial = ::std::option::Option::None;
    }

    pub fn has_only_for_this_serial(&self) -> bool {
        self.only_for_this_serial.is_some()
    }

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

impl ::protobuf::Message for CAccountHardware_SteamControllerSetConfig_Request {
    fn is_initialized(&self) -> bool {
        for v in &self.configurations {
            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_string_into(wire_type, is, &mut self.serial_number)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.controller_code)?;
                },
                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.accountid = ::std::option::Option::Some(tmp);
                },
                4 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.configurations)?;
                },
                5 => {
                    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.controller_type = ::std::option::Option::Some(tmp);
                },
                6 => {
                    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.only_for_this_serial = ::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.serial_number.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.controller_code.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.accountid {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.configurations {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(v) = self.controller_type {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.only_for_this_serial {
            my_size += 2;
        }
        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.serial_number.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.controller_code.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.accountid {
            os.write_uint32(3, v)?;
        }
        for v in &self.configurations {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(v) = self.controller_type {
            os.write_int32(5, v)?;
        }
        if let Some(v) = self.only_for_this_serial {
            os.write_bool(6, 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() -> CAccountHardware_SteamControllerSetConfig_Request {
        CAccountHardware_SteamControllerSetConfig_Request::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::ProtobufTypeString>(
                "serial_number",
                |m: &CAccountHardware_SteamControllerSetConfig_Request| { &m.serial_number },
                |m: &mut CAccountHardware_SteamControllerSetConfig_Request| { &mut m.serial_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "controller_code",
                |m: &CAccountHardware_SteamControllerSetConfig_Request| { &m.controller_code },
                |m: &mut CAccountHardware_SteamControllerSetConfig_Request| { &mut m.controller_code },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "accountid",
                |m: &CAccountHardware_SteamControllerSetConfig_Request| { &m.accountid },
                |m: &mut CAccountHardware_SteamControllerSetConfig_Request| { &mut m.accountid },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CAccountHardware_SteamControllerSetConfig_ControllerConfig>>(
                "configurations",
                |m: &CAccountHardware_SteamControllerSetConfig_Request| { &m.configurations },
                |m: &mut CAccountHardware_SteamControllerSetConfig_Request| { &mut m.configurations },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "controller_type",
                |m: &CAccountHardware_SteamControllerSetConfig_Request| { &m.controller_type },
                |m: &mut CAccountHardware_SteamControllerSetConfig_Request| { &mut m.controller_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "only_for_this_serial",
                |m: &CAccountHardware_SteamControllerSetConfig_Request| { &m.only_for_this_serial },
                |m: &mut CAccountHardware_SteamControllerSetConfig_Request| { &mut m.only_for_this_serial },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_SteamControllerSetConfig_Request>(
                "CAccountHardware_SteamControllerSetConfig_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CAccountHardware_SteamControllerSetConfig_Request {
    fn clear(&mut self) {
        self.serial_number.clear();
        self.controller_code.clear();
        self.accountid = ::std::option::Option::None;
        self.configurations.clear();
        self.controller_type = ::std::option::Option::None;
        self.only_for_this_serial = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

impl ::protobuf::Message for CAccountHardware_SteamControllerSetConfig_Response {
    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() -> CAccountHardware_SteamControllerSetConfig_Response {
        CAccountHardware_SteamControllerSetConfig_Response::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::<CAccountHardware_SteamControllerSetConfig_Response>(
                "CAccountHardware_SteamControllerSetConfig_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountHardware_SteamControllerGetConfig_Request {
    // message fields
    serial_number: ::protobuf::SingularField<::std::string::String>,
    controller_code: ::protobuf::SingularField<::std::string::String>,
    accountid: ::std::option::Option<u32>,
    appidorname: ::protobuf::SingularField<::std::string::String>,
    controller_type: ::std::option::Option<i32>,
    only_for_this_serial: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string serial_number = 1;


    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 string controller_code = 2;


    pub fn get_controller_code(&self) -> &str {
        match self.controller_code.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_controller_code(&mut self) {
        self.controller_code.clear();
    }

    pub fn has_controller_code(&self) -> bool {
        self.controller_code.is_some()
    }

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

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

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

    // optional uint32 accountid = 3;


    pub fn get_accountid(&self) -> u32 {
        self.accountid.unwrap_or(0)
    }
    pub fn clear_accountid(&mut self) {
        self.accountid = ::std::option::Option::None;
    }

    pub fn has_accountid(&self) -> bool {
        self.accountid.is_some()
    }

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

    // optional string appidorname = 4;


    pub fn get_appidorname(&self) -> &str {
        match self.appidorname.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_appidorname(&mut self) {
        self.appidorname.clear();
    }

    pub fn has_appidorname(&self) -> bool {
        self.appidorname.is_some()
    }

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

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

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

    // optional int32 controller_type = 5;


    pub fn get_controller_type(&self) -> i32 {
        self.controller_type.unwrap_or(2i32)
    }
    pub fn clear_controller_type(&mut self) {
        self.controller_type = ::std::option::Option::None;
    }

    pub fn has_controller_type(&self) -> bool {
        self.controller_type.is_some()
    }

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

    // optional bool only_for_this_serial = 6;


    pub fn get_only_for_this_serial(&self) -> bool {
        self.only_for_this_serial.unwrap_or(false)
    }
    pub fn clear_only_for_this_serial(&mut self) {
        self.only_for_this_serial = ::std::option::Option::None;
    }

    pub fn has_only_for_this_serial(&self) -> bool {
        self.only_for_this_serial.is_some()
    }

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

impl ::protobuf::Message for CAccountHardware_SteamControllerGetConfig_Request {
    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_string_into(wire_type, is, &mut self.serial_number)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.controller_code)?;
                },
                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.accountid = ::std::option::Option::Some(tmp);
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.appidorname)?;
                },
                5 => {
                    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.controller_type = ::std::option::Option::Some(tmp);
                },
                6 => {
                    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.only_for_this_serial = ::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.serial_number.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.controller_code.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.accountid {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.appidorname.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.controller_type {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.only_for_this_serial {
            my_size += 2;
        }
        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.serial_number.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.controller_code.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.accountid {
            os.write_uint32(3, v)?;
        }
        if let Some(ref v) = self.appidorname.as_ref() {
            os.write_string(4, &v)?;
        }
        if let Some(v) = self.controller_type {
            os.write_int32(5, v)?;
        }
        if let Some(v) = self.only_for_this_serial {
            os.write_bool(6, 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() -> CAccountHardware_SteamControllerGetConfig_Request {
        CAccountHardware_SteamControllerGetConfig_Request::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::ProtobufTypeString>(
                "serial_number",
                |m: &CAccountHardware_SteamControllerGetConfig_Request| { &m.serial_number },
                |m: &mut CAccountHardware_SteamControllerGetConfig_Request| { &mut m.serial_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "controller_code",
                |m: &CAccountHardware_SteamControllerGetConfig_Request| { &m.controller_code },
                |m: &mut CAccountHardware_SteamControllerGetConfig_Request| { &mut m.controller_code },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "accountid",
                |m: &CAccountHardware_SteamControllerGetConfig_Request| { &m.accountid },
                |m: &mut CAccountHardware_SteamControllerGetConfig_Request| { &mut m.accountid },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "appidorname",
                |m: &CAccountHardware_SteamControllerGetConfig_Request| { &m.appidorname },
                |m: &mut CAccountHardware_SteamControllerGetConfig_Request| { &mut m.appidorname },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "controller_type",
                |m: &CAccountHardware_SteamControllerGetConfig_Request| { &m.controller_type },
                |m: &mut CAccountHardware_SteamControllerGetConfig_Request| { &mut m.controller_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "only_for_this_serial",
                |m: &CAccountHardware_SteamControllerGetConfig_Request| { &m.only_for_this_serial },
                |m: &mut CAccountHardware_SteamControllerGetConfig_Request| { &mut m.only_for_this_serial },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_SteamControllerGetConfig_Request>(
                "CAccountHardware_SteamControllerGetConfig_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CAccountHardware_SteamControllerGetConfig_Request {
    fn clear(&mut self) {
        self.serial_number.clear();
        self.controller_code.clear();
        self.accountid = ::std::option::Option::None;
        self.appidorname.clear();
        self.controller_type = ::std::option::Option::None;
        self.only_for_this_serial = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountHardware_SteamControllerGetConfig_ControllerConfig {
    // message fields
    appidorname: ::protobuf::SingularField<::std::string::String>,
    publishedfileid: ::std::option::Option<u64>,
    templatename: ::protobuf::SingularField<::std::string::String>,
    serial_number: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string appidorname = 1;


    pub fn get_appidorname(&self) -> &str {
        match self.appidorname.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_appidorname(&mut self) {
        self.appidorname.clear();
    }

    pub fn has_appidorname(&self) -> bool {
        self.appidorname.is_some()
    }

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

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

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

    // optional uint64 publishedfileid = 2;


    pub fn get_publishedfileid(&self) -> u64 {
        self.publishedfileid.unwrap_or(0)
    }
    pub fn clear_publishedfileid(&mut self) {
        self.publishedfileid = ::std::option::Option::None;
    }

    pub fn has_publishedfileid(&self) -> bool {
        self.publishedfileid.is_some()
    }

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

    // optional string templatename = 3;


    pub fn get_templatename(&self) -> &str {
        match self.templatename.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_templatename(&mut self) {
        self.templatename.clear();
    }

    pub fn has_templatename(&self) -> bool {
        self.templatename.is_some()
    }

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

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

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

    // optional string serial_number = 4;


    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())
    }
}

impl ::protobuf::Message for CAccountHardware_SteamControllerGetConfig_ControllerConfig {
    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_string_into(wire_type, is, &mut self.appidorname)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.publishedfileid = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.templatename)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.serial_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;
        if let Some(ref v) = self.appidorname.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.publishedfileid {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.templatename.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(ref v) = self.serial_number.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &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(ref v) = self.appidorname.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(v) = self.publishedfileid {
            os.write_uint64(2, v)?;
        }
        if let Some(ref v) = self.templatename.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(ref v) = self.serial_number.as_ref() {
            os.write_string(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() -> CAccountHardware_SteamControllerGetConfig_ControllerConfig {
        CAccountHardware_SteamControllerGetConfig_ControllerConfig::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::ProtobufTypeString>(
                "appidorname",
                |m: &CAccountHardware_SteamControllerGetConfig_ControllerConfig| { &m.appidorname },
                |m: &mut CAccountHardware_SteamControllerGetConfig_ControllerConfig| { &mut m.appidorname },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "publishedfileid",
                |m: &CAccountHardware_SteamControllerGetConfig_ControllerConfig| { &m.publishedfileid },
                |m: &mut CAccountHardware_SteamControllerGetConfig_ControllerConfig| { &mut m.publishedfileid },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "templatename",
                |m: &CAccountHardware_SteamControllerGetConfig_ControllerConfig| { &m.templatename },
                |m: &mut CAccountHardware_SteamControllerGetConfig_ControllerConfig| { &mut m.templatename },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "serial_number",
                |m: &CAccountHardware_SteamControllerGetConfig_ControllerConfig| { &m.serial_number },
                |m: &mut CAccountHardware_SteamControllerGetConfig_ControllerConfig| { &mut m.serial_number },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_SteamControllerGetConfig_ControllerConfig>(
                "CAccountHardware_SteamControllerGetConfig_ControllerConfig",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CAccountHardware_SteamControllerGetConfig_ControllerConfig {
    fn clear(&mut self) {
        self.appidorname.clear();
        self.publishedfileid = ::std::option::Option::None;
        self.templatename.clear();
        self.serial_number.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // repeated .CAccountHardware_SteamControllerGetConfig_ControllerConfig configurations = 1;


    pub fn get_configurations(&self) -> &[CAccountHardware_SteamControllerGetConfig_ControllerConfig] {
        &self.configurations
    }
    pub fn clear_configurations(&mut self) {
        self.configurations.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_configurations(&mut self) -> &mut ::protobuf::RepeatedField<CAccountHardware_SteamControllerGetConfig_ControllerConfig> {
        &mut self.configurations
    }

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

impl ::protobuf::Message for CAccountHardware_SteamControllerGetConfig_Response {
    fn is_initialized(&self) -> bool {
        for v in &self.configurations {
            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.configurations)?;
                },
                _ => {
                    ::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.configurations {
            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.configurations {
            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() -> CAccountHardware_SteamControllerGetConfig_Response {
        CAccountHardware_SteamControllerGetConfig_Response::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<CAccountHardware_SteamControllerGetConfig_ControllerConfig>>(
                "configurations",
                |m: &CAccountHardware_SteamControllerGetConfig_Response| { &m.configurations },
                |m: &mut CAccountHardware_SteamControllerGetConfig_Response| { &mut m.configurations },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_SteamControllerGetConfig_Response>(
                "CAccountHardware_SteamControllerGetConfig_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountHardware_DeRegisterSteamController_Request {
    // message fields
    serial_number: ::protobuf::SingularField<::std::string::String>,
    controller_code: ::protobuf::SingularField<::std::string::String>,
    accountid: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string serial_number = 1;


    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 string controller_code = 2;


    pub fn get_controller_code(&self) -> &str {
        match self.controller_code.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_controller_code(&mut self) {
        self.controller_code.clear();
    }

    pub fn has_controller_code(&self) -> bool {
        self.controller_code.is_some()
    }

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

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

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

    // optional uint32 accountid = 3;


    pub fn get_accountid(&self) -> u32 {
        self.accountid.unwrap_or(0)
    }
    pub fn clear_accountid(&mut self) {
        self.accountid = ::std::option::Option::None;
    }

    pub fn has_accountid(&self) -> bool {
        self.accountid.is_some()
    }

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

impl ::protobuf::Message for CAccountHardware_DeRegisterSteamController_Request {
    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_string_into(wire_type, is, &mut self.serial_number)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.controller_code)?;
                },
                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.accountid = ::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.serial_number.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.controller_code.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.accountid {
            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(ref v) = self.serial_number.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.controller_code.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.accountid {
            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() -> CAccountHardware_DeRegisterSteamController_Request {
        CAccountHardware_DeRegisterSteamController_Request::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::ProtobufTypeString>(
                "serial_number",
                |m: &CAccountHardware_DeRegisterSteamController_Request| { &m.serial_number },
                |m: &mut CAccountHardware_DeRegisterSteamController_Request| { &mut m.serial_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "controller_code",
                |m: &CAccountHardware_DeRegisterSteamController_Request| { &m.controller_code },
                |m: &mut CAccountHardware_DeRegisterSteamController_Request| { &mut m.controller_code },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "accountid",
                |m: &CAccountHardware_DeRegisterSteamController_Request| { &m.accountid },
                |m: &mut CAccountHardware_DeRegisterSteamController_Request| { &mut m.accountid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_DeRegisterSteamController_Request>(
                "CAccountHardware_DeRegisterSteamController_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CAccountHardware_DeRegisterSteamController_Request {
    fn clear(&mut self) {
        self.serial_number.clear();
        self.controller_code.clear();
        self.accountid = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

impl ::protobuf::Message for CAccountHardware_DeRegisterSteamController_Response {
    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() -> CAccountHardware_DeRegisterSteamController_Response {
        CAccountHardware_DeRegisterSteamController_Response::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::<CAccountHardware_DeRegisterSteamController_Response>(
                "CAccountHardware_DeRegisterSteamController_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountHardware_SetPersonalizationFile_Request {
    // message fields
    serial_number: ::protobuf::SingularField<::std::string::String>,
    publishedfileid: ::std::option::Option<u64>,
    accountid: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string serial_number = 1;


    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 uint64 publishedfileid = 2;


    pub fn get_publishedfileid(&self) -> u64 {
        self.publishedfileid.unwrap_or(0)
    }
    pub fn clear_publishedfileid(&mut self) {
        self.publishedfileid = ::std::option::Option::None;
    }

    pub fn has_publishedfileid(&self) -> bool {
        self.publishedfileid.is_some()
    }

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

    // optional uint32 accountid = 3;


    pub fn get_accountid(&self) -> u32 {
        self.accountid.unwrap_or(0)
    }
    pub fn clear_accountid(&mut self) {
        self.accountid = ::std::option::Option::None;
    }

    pub fn has_accountid(&self) -> bool {
        self.accountid.is_some()
    }

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

impl ::protobuf::Message for CAccountHardware_SetPersonalizationFile_Request {
    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_string_into(wire_type, is, &mut self.serial_number)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.publishedfileid = ::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_uint32()?;
                    self.accountid = ::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.serial_number.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.publishedfileid {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.accountid {
            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(ref v) = self.serial_number.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(v) = self.publishedfileid {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.accountid {
            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() -> CAccountHardware_SetPersonalizationFile_Request {
        CAccountHardware_SetPersonalizationFile_Request::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::ProtobufTypeString>(
                "serial_number",
                |m: &CAccountHardware_SetPersonalizationFile_Request| { &m.serial_number },
                |m: &mut CAccountHardware_SetPersonalizationFile_Request| { &mut m.serial_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "publishedfileid",
                |m: &CAccountHardware_SetPersonalizationFile_Request| { &m.publishedfileid },
                |m: &mut CAccountHardware_SetPersonalizationFile_Request| { &mut m.publishedfileid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "accountid",
                |m: &CAccountHardware_SetPersonalizationFile_Request| { &m.accountid },
                |m: &mut CAccountHardware_SetPersonalizationFile_Request| { &mut m.accountid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_SetPersonalizationFile_Request>(
                "CAccountHardware_SetPersonalizationFile_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CAccountHardware_SetPersonalizationFile_Request {
    fn clear(&mut self) {
        self.serial_number.clear();
        self.publishedfileid = ::std::option::Option::None;
        self.accountid = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

impl ::protobuf::Message for CAccountHardware_SetPersonalizationFile_Response {
    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() -> CAccountHardware_SetPersonalizationFile_Response {
        CAccountHardware_SetPersonalizationFile_Response::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::<CAccountHardware_SetPersonalizationFile_Response>(
                "CAccountHardware_SetPersonalizationFile_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountHardware_GetPersonalizationFile_Request {
    // message fields
    serial_number: ::protobuf::SingularField<::std::string::String>,
    accountid: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string serial_number = 1;


    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 accountid = 2;


    pub fn get_accountid(&self) -> u32 {
        self.accountid.unwrap_or(0)
    }
    pub fn clear_accountid(&mut self) {
        self.accountid = ::std::option::Option::None;
    }

    pub fn has_accountid(&self) -> bool {
        self.accountid.is_some()
    }

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

impl ::protobuf::Message for CAccountHardware_GetPersonalizationFile_Request {
    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_string_into(wire_type, is, &mut self.serial_number)?;
                },
                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.accountid = ::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.serial_number.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.accountid {
            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(ref v) = self.serial_number.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(v) = self.accountid {
            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() -> CAccountHardware_GetPersonalizationFile_Request {
        CAccountHardware_GetPersonalizationFile_Request::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::ProtobufTypeString>(
                "serial_number",
                |m: &CAccountHardware_GetPersonalizationFile_Request| { &m.serial_number },
                |m: &mut CAccountHardware_GetPersonalizationFile_Request| { &mut m.serial_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "accountid",
                |m: &CAccountHardware_GetPersonalizationFile_Request| { &m.accountid },
                |m: &mut CAccountHardware_GetPersonalizationFile_Request| { &mut m.accountid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_GetPersonalizationFile_Request>(
                "CAccountHardware_GetPersonalizationFile_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional uint64 publishedfileid = 1;


    pub fn get_publishedfileid(&self) -> u64 {
        self.publishedfileid.unwrap_or(0)
    }
    pub fn clear_publishedfileid(&mut self) {
        self.publishedfileid = ::std::option::Option::None;
    }

    pub fn has_publishedfileid(&self) -> bool {
        self.publishedfileid.is_some()
    }

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

impl ::protobuf::Message for CAccountHardware_GetPersonalizationFile_Response {
    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_uint64()?;
                    self.publishedfileid = ::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.publishedfileid {
            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.publishedfileid {
            os.write_uint64(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() -> CAccountHardware_GetPersonalizationFile_Response {
        CAccountHardware_GetPersonalizationFile_Response::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::ProtobufTypeUint64>(
                "publishedfileid",
                |m: &CAccountHardware_GetPersonalizationFile_Response| { &m.publishedfileid },
                |m: &mut CAccountHardware_GetPersonalizationFile_Response| { &mut m.publishedfileid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_GetPersonalizationFile_Response>(
                "CAccountHardware_GetPersonalizationFile_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountHardware_VRCompatibilityCheck_Request {
    // message fields
    product_name: ::protobuf::SingularField<::std::string::String>,
    pub values: ::protobuf::RepeatedField<CAccountHardware_VRCompatibilityCheck_Request_Pair>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string product_name = 1;


    pub fn get_product_name(&self) -> &str {
        match self.product_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_product_name(&mut self) {
        self.product_name.clear();
    }

    pub fn has_product_name(&self) -> bool {
        self.product_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_product_name(&mut self, v: ::std::string::String) {
        self.product_name = ::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_name(&mut self) -> &mut ::std::string::String {
        if self.product_name.is_none() {
            self.product_name.set_default();
        }
        self.product_name.as_mut().unwrap()
    }

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

    // repeated .CAccountHardware_VRCompatibilityCheck_Request.Pair values = 2;


    pub fn get_values(&self) -> &[CAccountHardware_VRCompatibilityCheck_Request_Pair] {
        &self.values
    }
    pub fn clear_values(&mut self) {
        self.values.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<CAccountHardware_VRCompatibilityCheck_Request_Pair> {
        &mut self.values
    }

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

impl ::protobuf::Message for CAccountHardware_VRCompatibilityCheck_Request {
    fn is_initialized(&self) -> bool {
        for v in &self.values {
            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_string_into(wire_type, is, &mut self.product_name)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.values)?;
                },
                _ => {
                    ::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.product_name.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        for value in &self.values {
            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(ref v) = self.product_name.as_ref() {
            os.write_string(1, &v)?;
        }
        for v in &self.values {
            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() -> CAccountHardware_VRCompatibilityCheck_Request {
        CAccountHardware_VRCompatibilityCheck_Request::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::ProtobufTypeString>(
                "product_name",
                |m: &CAccountHardware_VRCompatibilityCheck_Request| { &m.product_name },
                |m: &mut CAccountHardware_VRCompatibilityCheck_Request| { &mut m.product_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CAccountHardware_VRCompatibilityCheck_Request_Pair>>(
                "values",
                |m: &CAccountHardware_VRCompatibilityCheck_Request| { &m.values },
                |m: &mut CAccountHardware_VRCompatibilityCheck_Request| { &mut m.values },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_VRCompatibilityCheck_Request>(
                "CAccountHardware_VRCompatibilityCheck_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountHardware_VRCompatibilityCheck_Request_Pair {
    // message fields
    key: ::protobuf::SingularField<::std::string::String>,
    value: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string key = 1;


    pub fn get_key(&self) -> &str {
        match self.key.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_key(&mut self) {
        self.key.clear();
    }

    pub fn has_key(&self) -> bool {
        self.key.is_some()
    }

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

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

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

    // optional string value = 2;


    pub fn get_value(&self) -> &str {
        match self.value.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

    pub fn has_value(&self) -> bool {
        self.value.is_some()
    }

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

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

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

impl ::protobuf::Message for CAccountHardware_VRCompatibilityCheck_Request_Pair {
    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_string_into(wire_type, is, &mut self.key)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.value)?;
                },
                _ => {
                    ::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.key.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.value.as_ref() {
            my_size += ::protobuf::rt::string_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(ref v) = self.key.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.value.as_ref() {
            os.write_string(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() -> CAccountHardware_VRCompatibilityCheck_Request_Pair {
        CAccountHardware_VRCompatibilityCheck_Request_Pair::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::ProtobufTypeString>(
                "key",
                |m: &CAccountHardware_VRCompatibilityCheck_Request_Pair| { &m.key },
                |m: &mut CAccountHardware_VRCompatibilityCheck_Request_Pair| { &mut m.key },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "value",
                |m: &CAccountHardware_VRCompatibilityCheck_Request_Pair| { &m.value },
                |m: &mut CAccountHardware_VRCompatibilityCheck_Request_Pair| { &mut m.value },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_VRCompatibilityCheck_Request_Pair>(
                "CAccountHardware_VRCompatibilityCheck_Request.Pair",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountHardware_VRCompatibilityCheck_Response {
    // message fields
    pub values: ::protobuf::RepeatedField<CAccountHardware_VRCompatibilityCheck_Response_Pair>,
    pub components: ::protobuf::RepeatedField<CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .CAccountHardware_VRCompatibilityCheck_Response.Pair values = 1;


    pub fn get_values(&self) -> &[CAccountHardware_VRCompatibilityCheck_Response_Pair] {
        &self.values
    }
    pub fn clear_values(&mut self) {
        self.values.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<CAccountHardware_VRCompatibilityCheck_Response_Pair> {
        &mut self.values
    }

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

    // repeated .CAccountHardware_VRCompatibilityCheck_Response.ComponentDisplay components = 2;


    pub fn get_components(&self) -> &[CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay] {
        &self.components
    }
    pub fn clear_components(&mut self) {
        self.components.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_components(&mut self) -> &mut ::protobuf::RepeatedField<CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay> {
        &mut self.components
    }

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

impl ::protobuf::Message for CAccountHardware_VRCompatibilityCheck_Response {
    fn is_initialized(&self) -> bool {
        for v in &self.values {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.components {
            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.values)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.components)?;
                },
                _ => {
                    ::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.values {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in &self.components {
            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.values {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        for v in &self.components {
            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() -> CAccountHardware_VRCompatibilityCheck_Response {
        CAccountHardware_VRCompatibilityCheck_Response::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<CAccountHardware_VRCompatibilityCheck_Response_Pair>>(
                "values",
                |m: &CAccountHardware_VRCompatibilityCheck_Response| { &m.values },
                |m: &mut CAccountHardware_VRCompatibilityCheck_Response| { &mut m.values },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay>>(
                "components",
                |m: &CAccountHardware_VRCompatibilityCheck_Response| { &m.components },
                |m: &mut CAccountHardware_VRCompatibilityCheck_Response| { &mut m.components },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_VRCompatibilityCheck_Response>(
                "CAccountHardware_VRCompatibilityCheck_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountHardware_VRCompatibilityCheck_Response_Pair {
    // message fields
    key: ::protobuf::SingularField<::std::string::String>,
    value: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string key = 1;


    pub fn get_key(&self) -> &str {
        match self.key.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_key(&mut self) {
        self.key.clear();
    }

    pub fn has_key(&self) -> bool {
        self.key.is_some()
    }

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

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

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

    // optional string value = 2;


    pub fn get_value(&self) -> &str {
        match self.value.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

    pub fn has_value(&self) -> bool {
        self.value.is_some()
    }

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

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

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

impl ::protobuf::Message for CAccountHardware_VRCompatibilityCheck_Response_Pair {
    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_string_into(wire_type, is, &mut self.key)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.value)?;
                },
                _ => {
                    ::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.key.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.value.as_ref() {
            my_size += ::protobuf::rt::string_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(ref v) = self.key.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.value.as_ref() {
            os.write_string(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() -> CAccountHardware_VRCompatibilityCheck_Response_Pair {
        CAccountHardware_VRCompatibilityCheck_Response_Pair::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::ProtobufTypeString>(
                "key",
                |m: &CAccountHardware_VRCompatibilityCheck_Response_Pair| { &m.key },
                |m: &mut CAccountHardware_VRCompatibilityCheck_Response_Pair| { &mut m.key },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "value",
                |m: &CAccountHardware_VRCompatibilityCheck_Response_Pair| { &m.value },
                |m: &mut CAccountHardware_VRCompatibilityCheck_Response_Pair| { &mut m.value },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_VRCompatibilityCheck_Response_Pair>(
                "CAccountHardware_VRCompatibilityCheck_Response.Pair",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay {
    // message fields
    name: ::protobuf::SingularField<::std::string::String>,
    image: ::protobuf::SingularField<::std::string::String>,
    value: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string name = 1;


    pub fn get_name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    pub fn has_name(&self) -> bool {
        self.name.is_some()
    }

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

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

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

    // optional string image = 2;


    pub fn get_image(&self) -> &str {
        match self.image.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_image(&mut self) {
        self.image.clear();
    }

    pub fn has_image(&self) -> bool {
        self.image.is_some()
    }

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

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

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

    // optional string value = 3;


    pub fn get_value(&self) -> &str {
        match self.value.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

    pub fn has_value(&self) -> bool {
        self.value.is_some()
    }

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

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

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

impl ::protobuf::Message for CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay {
    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_string_into(wire_type, is, &mut self.name)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.image)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.value)?;
                },
                _ => {
                    ::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.name.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.image.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(ref v) = self.value.as_ref() {
            my_size += ::protobuf::rt::string_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(ref v) = self.name.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.image.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(ref v) = self.value.as_ref() {
            os.write_string(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() -> CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay {
        CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay::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::ProtobufTypeString>(
                "name",
                |m: &CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay| { &m.name },
                |m: &mut CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "image",
                |m: &CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay| { &m.image },
                |m: &mut CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay| { &mut m.image },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "value",
                |m: &CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay| { &m.value },
                |m: &mut CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay| { &mut m.value },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay>(
                "CAccountHardware_VRCompatibilityCheck_Response.ComponentDisplay",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CAccountHardware_VRCompatibilityCheck_Response_ComponentDisplay {
    fn clear(&mut self) {
        self.name.clear();
        self.image.clear();
        self.value.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountHardware_RegisterValveIndexComponent_Request {
    // message fields
    serial_number: ::protobuf::SingularField<::std::string::String>,
    manufacturer_serial_number: ::protobuf::SingularField<::std::string::String>,
    component_code: ::protobuf::SingularField<::std::string::String>,
    component_type: ::std::option::Option<EValveIndexComponent>,
    estimated_time_registered: ::std::option::Option<i32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string serial_number = 1;


    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 string manufacturer_serial_number = 2;


    pub fn get_manufacturer_serial_number(&self) -> &str {
        match self.manufacturer_serial_number.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_manufacturer_serial_number(&mut self) {
        self.manufacturer_serial_number.clear();
    }

    pub fn has_manufacturer_serial_number(&self) -> bool {
        self.manufacturer_serial_number.is_some()
    }

    // Param is passed by value, moved
    pub fn set_manufacturer_serial_number(&mut self, v: ::std::string::String) {
        self.manufacturer_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_manufacturer_serial_number(&mut self) -> &mut ::std::string::String {
        if self.manufacturer_serial_number.is_none() {
            self.manufacturer_serial_number.set_default();
        }
        self.manufacturer_serial_number.as_mut().unwrap()
    }

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

    // optional string component_code = 3;


    pub fn get_component_code(&self) -> &str {
        match self.component_code.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_component_code(&mut self) {
        self.component_code.clear();
    }

    pub fn has_component_code(&self) -> bool {
        self.component_code.is_some()
    }

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

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

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

    // optional .EValveIndexComponent component_type = 4;


    pub fn get_component_type(&self) -> EValveIndexComponent {
        self.component_type.unwrap_or(EValveIndexComponent::k_EValveIndexComponentUnknown)
    }
    pub fn clear_component_type(&mut self) {
        self.component_type = ::std::option::Option::None;
    }

    pub fn has_component_type(&self) -> bool {
        self.component_type.is_some()
    }

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

    // optional int32 estimated_time_registered = 5;


    pub fn get_estimated_time_registered(&self) -> i32 {
        self.estimated_time_registered.unwrap_or(0)
    }
    pub fn clear_estimated_time_registered(&mut self) {
        self.estimated_time_registered = ::std::option::Option::None;
    }

    pub fn has_estimated_time_registered(&self) -> bool {
        self.estimated_time_registered.is_some()
    }

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

impl ::protobuf::Message for CAccountHardware_RegisterValveIndexComponent_Request {
    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_string_into(wire_type, is, &mut self.serial_number)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.manufacturer_serial_number)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.component_code)?;
                },
                4 => {
                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.component_type, 4, &mut self.unknown_fields)?
                },
                5 => {
                    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.estimated_time_registered = ::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.serial_number.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.manufacturer_serial_number.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(ref v) = self.component_code.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.component_type {
            my_size += ::protobuf::rt::enum_size(4, v);
        }
        if let Some(v) = self.estimated_time_registered {
            my_size += ::protobuf::rt::value_size(5, 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.serial_number.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.manufacturer_serial_number.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(ref v) = self.component_code.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(v) = self.component_type {
            os.write_enum(4, ::protobuf::ProtobufEnum::value(&v))?;
        }
        if let Some(v) = self.estimated_time_registered {
            os.write_int32(5, 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() -> CAccountHardware_RegisterValveIndexComponent_Request {
        CAccountHardware_RegisterValveIndexComponent_Request::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::ProtobufTypeString>(
                "serial_number",
                |m: &CAccountHardware_RegisterValveIndexComponent_Request| { &m.serial_number },
                |m: &mut CAccountHardware_RegisterValveIndexComponent_Request| { &mut m.serial_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "manufacturer_serial_number",
                |m: &CAccountHardware_RegisterValveIndexComponent_Request| { &m.manufacturer_serial_number },
                |m: &mut CAccountHardware_RegisterValveIndexComponent_Request| { &mut m.manufacturer_serial_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "component_code",
                |m: &CAccountHardware_RegisterValveIndexComponent_Request| { &m.component_code },
                |m: &mut CAccountHardware_RegisterValveIndexComponent_Request| { &mut m.component_code },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EValveIndexComponent>>(
                "component_type",
                |m: &CAccountHardware_RegisterValveIndexComponent_Request| { &m.component_type },
                |m: &mut CAccountHardware_RegisterValveIndexComponent_Request| { &mut m.component_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "estimated_time_registered",
                |m: &CAccountHardware_RegisterValveIndexComponent_Request| { &m.estimated_time_registered },
                |m: &mut CAccountHardware_RegisterValveIndexComponent_Request| { &mut m.estimated_time_registered },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountHardware_RegisterValveIndexComponent_Request>(
                "CAccountHardware_RegisterValveIndexComponent_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CAccountHardware_RegisterValveIndexComponent_Request {
    fn clear(&mut self) {
        self.serial_number.clear();
        self.manufacturer_serial_number.clear();
        self.component_code.clear();
        self.component_type = ::std::option::Option::None;
        self.estimated_time_registered = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

impl ::protobuf::Message for CAccountHardware_RegisterValveIndexComponent_Response {
    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() -> CAccountHardware_RegisterValveIndexComponent_Response {
        CAccountHardware_RegisterValveIndexComponent_Response::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::<CAccountHardware_RegisterValveIndexComponent_Response>(
                "CAccountHardware_RegisterValveIndexComponent_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum EValveIndexComponent {
    k_EValveIndexComponentUnknown = 0,
    k_EValveIndexComponentHMD = 1,
    k_EValveIndexComponentLeftKnuckle = 2,
    k_EValveIndexComponentRightKnuckle = 3,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<EValveIndexComponent> {
        match value {
            0 => ::std::option::Option::Some(EValveIndexComponent::k_EValveIndexComponentUnknown),
            1 => ::std::option::Option::Some(EValveIndexComponent::k_EValveIndexComponentHMD),
            2 => ::std::option::Option::Some(EValveIndexComponent::k_EValveIndexComponentLeftKnuckle),
            3 => ::std::option::Option::Some(EValveIndexComponent::k_EValveIndexComponentRightKnuckle),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [EValveIndexComponent] = &[
            EValveIndexComponent::k_EValveIndexComponentUnknown,
            EValveIndexComponent::k_EValveIndexComponentHMD,
            EValveIndexComponent::k_EValveIndexComponentLeftKnuckle,
            EValveIndexComponent::k_EValveIndexComponentRightKnuckle,
        ];
        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::<EValveIndexComponent>("EValveIndexComponent", file_descriptor_proto())
        })
    }
}

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

impl ::std::default::Default for EValveIndexComponent {
    fn default() -> Self {
        EValveIndexComponent::k_EValveIndexComponentUnknown
    }
}

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n/steammessages_accounthardware.steamclient.proto\x1a,steammessages_uni\
    fied_base.steamclient.proto\"\x80\x01\n0CAccountHardware_RegisterSteamCo\
    ntroller_Request\x12#\n\rserial_number\x18\x01\x20\x01(\tR\x0cserialNumb\
    er\x12'\n\x0fcontroller_code\x18\x02\x20\x01(\tR\x0econtrollerCode\"3\n1\
    CAccountHardware_RegisterSteamController_Response\"\x8c\x01\n<CAccountHa\
    rdware_CompleteSteamControllerRegistration_Request\x12#\n\rserial_number\
    \x18\x01\x20\x01(\tR\x0cserialNumber\x12'\n\x0fcontroller_code\x18\x02\
    \x20\x01(\tR\x0econtrollerCode\"?\n=CAccountHardware_CompleteSteamContro\
    llerRegistration_Response\"\x88\x01\n8CAccountHardware_QueryAccountsRegi\
    steredToSerial_Request\x12#\n\rserial_number\x18\x01\x20\x01(\tR\x0cseri\
    alNumber\x12'\n\x0fcontroller_code\x18\x02\x20\x01(\tR\x0econtrollerCode\
    \"\x8e\x01\n9CAccountHardware_QueryAccountsRegisteredToSerial_Accounts\
    \x12\x1c\n\taccountid\x18\x01\x20\x01(\rR\taccountid\x123\n\x15registrat\
    ion_complete\x18\x02\x20\x01(\x08R\x14registrationComplete\"\x93\x01\n9C\
    AccountHardware_QueryAccountsRegisteredToSerial_Response\x12V\n\x08accou\
    nts\x18\x01\x20\x03(\x0b2:.CAccountHardware_QueryAccountsRegisteredToSer\
    ial_AccountsR\x08accounts\"\xac\x01\n:CAccountHardware_SteamControllerSe\
    tConfig_ControllerConfig\x12\x20\n\x0bappidorname\x18\x01\x20\x01(\tR\
    \x0bappidorname\x12(\n\x0fpublishedfileid\x18\x02\x20\x01(\x04R\x0fpubli\
    shedfileid\x12\"\n\x0ctemplatename\x18\x03\x20\x01(\tR\x0ctemplatename\"\
    \xe8\x02\n1CAccountHardware_SteamControllerSetConfig_Request\x12#\n\rser\
    ial_number\x18\x01\x20\x01(\tR\x0cserialNumber\x12'\n\x0fcontroller_code\
    \x18\x02\x20\x01(\tR\x0econtrollerCode\x12\x1c\n\taccountid\x18\x03\x20\
    \x01(\rR\taccountid\x12c\n\x0econfigurations\x18\x04\x20\x03(\x0b2;.CAcc\
    ountHardware_SteamControllerSetConfig_ControllerConfigR\x0econfiguration\
    s\x12*\n\x0fcontroller_type\x18\x05\x20\x01(\x05:\x012R\x0econtrollerTyp\
    e\x126\n\x14only_for_this_serial\x18\x06\x20\x01(\x08:\x05falseR\x11only\
    ForThisSerial\"4\n2CAccountHardware_SteamControllerSetConfig_Response\"\
    \xa5\x02\n1CAccountHardware_SteamControllerGetConfig_Request\x12#\n\rser\
    ial_number\x18\x01\x20\x01(\tR\x0cserialNumber\x12'\n\x0fcontroller_code\
    \x18\x02\x20\x01(\tR\x0econtrollerCode\x12\x1c\n\taccountid\x18\x03\x20\
    \x01(\rR\taccountid\x12\x20\n\x0bappidorname\x18\x04\x20\x01(\tR\x0bappi\
    dorname\x12*\n\x0fcontroller_type\x18\x05\x20\x01(\x05:\x012R\x0econtrol\
    lerType\x126\n\x14only_for_this_serial\x18\x06\x20\x01(\x08:\x05falseR\
    \x11onlyForThisSerial\"\xd1\x01\n:CAccountHardware_SteamControllerGetCon\
    fig_ControllerConfig\x12\x20\n\x0bappidorname\x18\x01\x20\x01(\tR\x0bapp\
    idorname\x12(\n\x0fpublishedfileid\x18\x02\x20\x01(\x04R\x0fpublishedfil\
    eid\x12\"\n\x0ctemplatename\x18\x03\x20\x01(\tR\x0ctemplatename\x12#\n\r\
    serial_number\x18\x04\x20\x01(\tR\x0cserialNumber\"\x99\x01\n2CAccountHa\
    rdware_SteamControllerGetConfig_Response\x12c\n\x0econfigurations\x18\
    \x01\x20\x03(\x0b2;.CAccountHardware_SteamControllerGetConfig_Controller\
    ConfigR\x0econfigurations\"\xa0\x01\n2CAccountHardware_DeRegisterSteamCo\
    ntroller_Request\x12#\n\rserial_number\x18\x01\x20\x01(\tR\x0cserialNumb\
    er\x12'\n\x0fcontroller_code\x18\x02\x20\x01(\tR\x0econtrollerCode\x12\
    \x1c\n\taccountid\x18\x03\x20\x01(\rR\taccountid\"5\n3CAccountHardware_D\
    eRegisterSteamController_Response\"\x9e\x01\n/CAccountHardware_SetPerson\
    alizationFile_Request\x12#\n\rserial_number\x18\x01\x20\x01(\tR\x0cseria\
    lNumber\x12(\n\x0fpublishedfileid\x18\x02\x20\x01(\x04R\x0fpublishedfile\
    id\x12\x1c\n\taccountid\x18\x03\x20\x01(\rR\taccountid\"2\n0CAccountHard\
    ware_SetPersonalizationFile_Response\"t\n/CAccountHardware_GetPersonaliz\
    ationFile_Request\x12#\n\rserial_number\x18\x01\x20\x01(\tR\x0cserialNum\
    ber\x12\x1c\n\taccountid\x18\x02\x20\x01(\rR\taccountid\"\\\n0CAccountHa\
    rdware_GetPersonalizationFile_Response\x12(\n\x0fpublishedfileid\x18\x01\
    \x20\x01(\x04R\x0fpublishedfileid\"\x98\x02\n-CAccountHardware_VRCompati\
    bilityCheck_Request\x12E\n\x0cproduct_name\x18\x01\x20\x01(\tR\x0bproduc\
    tNameB\"\x82\xb5\x18\x1eName\x20of\x20product\x20we're\x20checking\x12p\
    \n\x06values\x18\x02\x20\x03(\x0b23.CAccountHardware_VRCompatibilityChec\
    k_Request.PairR\x06valuesB#\x82\xb5\x18\x1fValues\x20from\x20client\x20s\
    ystem\x20probe\x1a.\n\x04Pair\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03ke\
    y\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value\"\x90\x04\n.CAccountHa\
    rdware_VRCompatibilityCheck_Response\x12u\n\x06values\x18\x01\x20\x03(\
    \x0b24.CAccountHardware_VRCompatibilityCheck_Response.PairR\x06valuesB'\
    \x82\xb5\x18#Top-level\x20values\x20reported\x20to\x20client\x12\x80\x01\
    \n\ncomponents\x18\x02\x20\x03(\x0b2@.CAccountHardware_VRCompatibilityCh\
    eck_Response.ComponentDisplayR\ncomponentsB\x1e\x82\xb5\x18\x1aSpecific\
    \x20values\x20to\x20display\x1a.\n\x04Pair\x12\x10\n\x03key\x18\x01\x20\
    \x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value\x1a\xb3\
    \x01\n\x10ComponentDisplay\x12>\n\x04name\x18\x01\x20\x01(\tR\x04nameB*\
    \x82\xb5\x18&Name\x20of\x20component\x20(OS,\x20RAM,\x20GPU,\x20etc.)\
    \x12-\n\x05image\x18\x02\x20\x01(\tR\x05imageB\x17\x82\xb5\x18\x13Name\
    \x20of\x20icon\x20to\x20use\x120\n\x05value\x18\x03\x20\x01(\tR\x05value\
    B\x1a\x82\xb5\x18\x16String\x20value\x20to\x20report\"\xd9\x02\n4CAccoun\
    tHardware_RegisterValveIndexComponent_Request\x12#\n\rserial_number\x18\
    \x01\x20\x01(\tR\x0cserialNumber\x12<\n\x1amanufacturer_serial_number\
    \x18\x02\x20\x01(\tR\x18manufacturerSerialNumber\x12%\n\x0ecomponent_cod\
    e\x18\x03\x20\x01(\tR\rcomponentCode\x12[\n\x0ecomponent_type\x18\x04\
    \x20\x01(\x0e2\x15.EValveIndexComponent:\x1dk_EValveIndexComponentUnknow\
    nR\rcomponentType\x12:\n\x19estimated_time_registered\x18\x05\x20\x01(\
    \x05R\x17estimatedTimeRegistered\"7\n5CAccountHardware_RegisterValveInde\
    xComponent_Response*\xa7\x01\n\x14EValveIndexComponent\x12!\n\x1dk_EValv\
    eIndexComponentUnknown\x10\0\x12\x1d\n\x19k_EValveIndexComponentHMD\x10\
    \x01\x12%\n!k_EValveIndexComponentLeftKnuckle\x10\x02\x12&\n\"k_EValveIn\
    dexComponentRightKnuckle\x10\x032\xea\x0f\n\x0fAccountHardware\x12\xd8\
    \x01\n\x17RegisterSteamController\x121.CAccountHardware_RegisterSteamCon\
    troller_Request\x1a2.CAccountHardware_RegisterSteamController_Response\"\
    V\x82\xb5\x18RRecords\x20a\x20serial\x20number\x20and\x20the\x20calling\
    \x20user's\x20account\x20info\x20for\x20warranty\x20purposes.\x12\xd7\
    \x01\n#CompleteSteamControllerRegistration\x12=.CAccountHardware_Complet\
    eSteamControllerRegistration_Request\x1a>.CAccountHardware_CompleteSteam\
    ControllerRegistration_Response\"1\x82\xb5\x18-Marks\x20a\x20controller'\
    s\x20registration\x20as\x20complete\x12\xdb\x01\n#QueryAccountsRegistere\
    dToController\x129.CAccountHardware_QueryAccountsRegisteredToSerial_Requ\
    est\x1a:.CAccountHardware_QueryAccountsRegisteredToSerial_Response\"=\
    \x82\xb5\x189Sends\x20back\x20a\x20list\x20of\x20accounts\x20registered\
    \x20to\x20a\x20controller.\x12\xbc\x01\n\x20SetDesiredControllerConfigFo\
    rApp\x122.CAccountHardware_SteamControllerSetConfig_Request\x1a3.CAccoun\
    tHardware_SteamControllerSetConfig_Response\"/\x82\xb5\x18+Sets\x20a\x20\
    desired\x20controller\x20config\x20for\x20an\x20app\x12\xbc\x01\n\x20Get\
    DesiredControllerConfigForApp\x122.CAccountHardware_SteamControllerGetCo\
    nfig_Request\x1a3.CAccountHardware_SteamControllerGetConfig_Response\"/\
    \x82\xb5\x18+Gets\x20a\x20desired\x20controller\x20config\x20for\x20an\
    \x20app\x12\xa5\x01\n\x19DeRegisterSteamController\x123.CAccountHardware\
    _DeRegisterSteamController_Request\x1a4.CAccountHardware_DeRegisterSteam\
    Controller_Response\"\x1d\x82\xb5\x18\x19De\x20registers\x20a\x20control\
    ler\x12\xbb\x01\n\x20SetControllerPersonalizationFile\x120.CAccountHardw\
    are_SetPersonalizationFile_Request\x1a1.CAccountHardware_SetPersonalizat\
    ionFile_Response\"2\x82\xb5\x18.Stores\x20the\x20file\x20ID\x20of\x20the\
    \x20personalization\x20file\x12\xb9\x01\n\x20GetControllerPersonalizatio\
    nFile\x120.CAccountHardware_GetPersonalizationFile_Request\x1a1.CAccount\
    Hardware_GetPersonalizationFile_Response\"0\x82\xb5\x18,Gets\x20the\x20f\
    ile\x20ID\x20of\x20the\x20personalization\x20file\x12\xa8\x01\n\x14VRCom\
    patibilityCheck\x12..CAccountHardware_VRCompatibilityCheck_Request\x1a/.\
    CAccountHardware_VRCompatibilityCheck_Response\"/\x82\xb5\x18+Check\x20s\
    ystem\x20info\x20for\x20compatibility\x20with\x20VR\x12\xc1\x01\n\x1bReg\
    isterValveIndexComponent\x125.CAccountHardware_RegisterValveIndexCompone\
    nt_Request\x1a6.CAccountHardware_RegisterValveIndexComponent_Response\"3\
    \x82\xb5\x18/Registers\x20a\x20valve\x20index\x20component\x20to\x20a\
    \x20customer\x1a5\x82\xb5\x181A\x20service\x20to\x20use\x20account\x20ha\
    rdware\x20related\x20methodsB\x03\x80\x01\x01J\xcf/\n\x07\x12\x05\0\0\
    \xb9\x01\x01\n\t\n\x02\x03\0\x12\x03\0\06\n\x08\n\x01\x08\x12\x03\x02\0\
    \"\n\t\n\x02\x08\x10\x12\x03\x02\0\"\n\n\n\x02\x05\0\x12\x04\x04\0\t\x01\
    \n\n\n\x03\x05\0\x01\x12\x03\x04\x05\x19\n\x0b\n\x04\x05\0\x02\0\x12\x03\
    \x05\x08*\n\x0c\n\x05\x05\0\x02\0\x01\x12\x03\x05\x08%\n\x0c\n\x05\x05\0\
    \x02\0\x02\x12\x03\x05()\n\x0b\n\x04\x05\0\x02\x01\x12\x03\x06\x08&\n\
    \x0c\n\x05\x05\0\x02\x01\x01\x12\x03\x06\x08!\n\x0c\n\x05\x05\0\x02\x01\
    \x02\x12\x03\x06$%\n\x0b\n\x04\x05\0\x02\x02\x12\x03\x07\x08.\n\x0c\n\
    \x05\x05\0\x02\x02\x01\x12\x03\x07\x08)\n\x0c\n\x05\x05\0\x02\x02\x02\
    \x12\x03\x07,-\n\x0b\n\x04\x05\0\x02\x03\x12\x03\x08\x08/\n\x0c\n\x05\
    \x05\0\x02\x03\x01\x12\x03\x08\x08*\n\x0c\n\x05\x05\0\x02\x03\x02\x12\
    \x03\x08-.\n\n\n\x02\x04\0\x12\x04\x0b\0\x0e\x01\n\n\n\x03\x04\0\x01\x12\
    \x03\x0b\x088\n\x0b\n\x04\x04\0\x02\0\x12\x03\x0c\x08*\n\x0c\n\x05\x04\0\
    \x02\0\x04\x12\x03\x0c\x08\x10\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x0c\
    \x11\x17\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x0c\x18%\n\x0c\n\x05\x04\0\
    \x02\0\x03\x12\x03\x0c()\n\x0b\n\x04\x04\0\x02\x01\x12\x03\r\x08,\n\x0c\
    \n\x05\x04\0\x02\x01\x04\x12\x03\r\x08\x10\n\x0c\n\x05\x04\0\x02\x01\x05\
    \x12\x03\r\x11\x17\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\r\x18'\n\x0c\n\
    \x05\x04\0\x02\x01\x03\x12\x03\r*+\n\n\n\x02\x04\x01\x12\x04\x10\0\x11\
    \x01\n\n\n\x03\x04\x01\x01\x12\x03\x10\x089\n\n\n\x02\x04\x02\x12\x04\
    \x13\0\x16\x01\n\n\n\x03\x04\x02\x01\x12\x03\x13\x08D\n\x0b\n\x04\x04\
    \x02\x02\0\x12\x03\x14\x08*\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03\x14\
    \x08\x10\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03\x14\x11\x17\n\x0c\n\x05\
    \x04\x02\x02\0\x01\x12\x03\x14\x18%\n\x0c\n\x05\x04\x02\x02\0\x03\x12\
    \x03\x14()\n\x0b\n\x04\x04\x02\x02\x01\x12\x03\x15\x08,\n\x0c\n\x05\x04\
    \x02\x02\x01\x04\x12\x03\x15\x08\x10\n\x0c\n\x05\x04\x02\x02\x01\x05\x12\
    \x03\x15\x11\x17\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03\x15\x18'\n\x0c\
    \n\x05\x04\x02\x02\x01\x03\x12\x03\x15*+\n\n\n\x02\x04\x03\x12\x04\x18\0\
    \x19\x01\n\n\n\x03\x04\x03\x01\x12\x03\x18\x08E\n\n\n\x02\x04\x04\x12\
    \x04\x1b\0\x1e\x01\n\n\n\x03\x04\x04\x01\x12\x03\x1b\x08@\n\x0b\n\x04\
    \x04\x04\x02\0\x12\x03\x1c\x08*\n\x0c\n\x05\x04\x04\x02\0\x04\x12\x03\
    \x1c\x08\x10\n\x0c\n\x05\x04\x04\x02\0\x05\x12\x03\x1c\x11\x17\n\x0c\n\
    \x05\x04\x04\x02\0\x01\x12\x03\x1c\x18%\n\x0c\n\x05\x04\x04\x02\0\x03\
    \x12\x03\x1c()\n\x0b\n\x04\x04\x04\x02\x01\x12\x03\x1d\x08,\n\x0c\n\x05\
    \x04\x04\x02\x01\x04\x12\x03\x1d\x08\x10\n\x0c\n\x05\x04\x04\x02\x01\x05\
    \x12\x03\x1d\x11\x17\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\x03\x1d\x18'\n\
    \x0c\n\x05\x04\x04\x02\x01\x03\x12\x03\x1d*+\n\n\n\x02\x04\x05\x12\x04\
    \x20\0#\x01\n\n\n\x03\x04\x05\x01\x12\x03\x20\x08A\n\x0b\n\x04\x04\x05\
    \x02\0\x12\x03!\x08&\n\x0c\n\x05\x04\x05\x02\0\x04\x12\x03!\x08\x10\n\
    \x0c\n\x05\x04\x05\x02\0\x05\x12\x03!\x11\x17\n\x0c\n\x05\x04\x05\x02\0\
    \x01\x12\x03!\x18!\n\x0c\n\x05\x04\x05\x02\0\x03\x12\x03!$%\n\x0b\n\x04\
    \x04\x05\x02\x01\x12\x03\"\x080\n\x0c\n\x05\x04\x05\x02\x01\x04\x12\x03\
    \"\x08\x10\n\x0c\n\x05\x04\x05\x02\x01\x05\x12\x03\"\x11\x15\n\x0c\n\x05\
    \x04\x05\x02\x01\x01\x12\x03\"\x16+\n\x0c\n\x05\x04\x05\x02\x01\x03\x12\
    \x03\"./\n\n\n\x02\x04\x06\x12\x04%\0'\x01\n\n\n\x03\x04\x06\x01\x12\x03\
    %\x08A\n\x0b\n\x04\x04\x06\x02\0\x12\x03&\x08Y\n\x0c\n\x05\x04\x06\x02\0\
    \x04\x12\x03&\x08\x10\n\x0c\n\x05\x04\x06\x02\0\x06\x12\x03&\x11K\n\x0c\
    \n\x05\x04\x06\x02\0\x01\x12\x03&LT\n\x0c\n\x05\x04\x06\x02\0\x03\x12\
    \x03&WX\n\n\n\x02\x04\x07\x12\x04)\0-\x01\n\n\n\x03\x04\x07\x01\x12\x03)\
    \x08B\n\x0b\n\x04\x04\x07\x02\0\x12\x03*\x08(\n\x0c\n\x05\x04\x07\x02\0\
    \x04\x12\x03*\x08\x10\n\x0c\n\x05\x04\x07\x02\0\x05\x12\x03*\x11\x17\n\
    \x0c\n\x05\x04\x07\x02\0\x01\x12\x03*\x18#\n\x0c\n\x05\x04\x07\x02\0\x03\
    \x12\x03*&'\n\x0b\n\x04\x04\x07\x02\x01\x12\x03+\x08,\n\x0c\n\x05\x04\
    \x07\x02\x01\x04\x12\x03+\x08\x10\n\x0c\n\x05\x04\x07\x02\x01\x05\x12\
    \x03+\x11\x17\n\x0c\n\x05\x04\x07\x02\x01\x01\x12\x03+\x18'\n\x0c\n\x05\
    \x04\x07\x02\x01\x03\x12\x03+*+\n\x0b\n\x04\x04\x07\x02\x02\x12\x03,\x08\
    )\n\x0c\n\x05\x04\x07\x02\x02\x04\x12\x03,\x08\x10\n\x0c\n\x05\x04\x07\
    \x02\x02\x05\x12\x03,\x11\x17\n\x0c\n\x05\x04\x07\x02\x02\x01\x12\x03,\
    \x18$\n\x0c\n\x05\x04\x07\x02\x02\x03\x12\x03,'(\n\n\n\x02\x04\x08\x12\
    \x04/\06\x01\n\n\n\x03\x04\x08\x01\x12\x03/\x089\n\x0b\n\x04\x04\x08\x02\
    \0\x12\x030\x08*\n\x0c\n\x05\x04\x08\x02\0\x04\x12\x030\x08\x10\n\x0c\n\
    \x05\x04\x08\x02\0\x05\x12\x030\x11\x17\n\x0c\n\x05\x04\x08\x02\0\x01\
    \x12\x030\x18%\n\x0c\n\x05\x04\x08\x02\0\x03\x12\x030()\n\x0b\n\x04\x04\
    \x08\x02\x01\x12\x031\x08,\n\x0c\n\x05\x04\x08\x02\x01\x04\x12\x031\x08\
    \x10\n\x0c\n\x05\x04\x08\x02\x01\x05\x12\x031\x11\x17\n\x0c\n\x05\x04\
    \x08\x02\x01\x01\x12\x031\x18'\n\x0c\n\x05\x04\x08\x02\x01\x03\x12\x031*\
    +\n\x0b\n\x04\x04\x08\x02\x02\x12\x032\x08&\n\x0c\n\x05\x04\x08\x02\x02\
    \x04\x12\x032\x08\x10\n\x0c\n\x05\x04\x08\x02\x02\x05\x12\x032\x11\x17\n\
    \x0c\n\x05\x04\x08\x02\x02\x01\x12\x032\x18!\n\x0c\n\x05\x04\x08\x02\x02\
    \x03\x12\x032$%\n\x0b\n\x04\x04\x08\x02\x03\x12\x033\x08`\n\x0c\n\x05\
    \x04\x08\x02\x03\x04\x12\x033\x08\x10\n\x0c\n\x05\x04\x08\x02\x03\x06\
    \x12\x033\x11L\n\x0c\n\x05\x04\x08\x02\x03\x01\x12\x033M[\n\x0c\n\x05\
    \x04\x08\x02\x03\x03\x12\x033^_\n\x0b\n\x04\x04\x08\x02\x04\x12\x034\x08\
    9\n\x0c\n\x05\x04\x08\x02\x04\x04\x12\x034\x08\x10\n\x0c\n\x05\x04\x08\
    \x02\x04\x05\x12\x034\x11\x16\n\x0c\n\x05\x04\x08\x02\x04\x01\x12\x034\
    \x17&\n\x0c\n\x05\x04\x08\x02\x04\x03\x12\x034)*\n\x0c\n\x05\x04\x08\x02\
    \x04\x08\x12\x034+8\n\x0c\n\x05\x04\x08\x02\x04\x07\x12\x03467\n\x0b\n\
    \x04\x04\x08\x02\x05\x12\x035\x08A\n\x0c\n\x05\x04\x08\x02\x05\x04\x12\
    \x035\x08\x10\n\x0c\n\x05\x04\x08\x02\x05\x05\x12\x035\x11\x15\n\x0c\n\
    \x05\x04\x08\x02\x05\x01\x12\x035\x16*\n\x0c\n\x05\x04\x08\x02\x05\x03\
    \x12\x035-.\n\x0c\n\x05\x04\x08\x02\x05\x08\x12\x035/@\n\x0c\n\x05\x04\
    \x08\x02\x05\x07\x12\x035:?\n\n\n\x02\x04\t\x12\x048\09\x01\n\n\n\x03\
    \x04\t\x01\x12\x038\x08:\n\n\n\x02\x04\n\x12\x04;\0B\x01\n\n\n\x03\x04\n\
    \x01\x12\x03;\x089\n\x0b\n\x04\x04\n\x02\0\x12\x03<\x08*\n\x0c\n\x05\x04\
    \n\x02\0\x04\x12\x03<\x08\x10\n\x0c\n\x05\x04\n\x02\0\x05\x12\x03<\x11\
    \x17\n\x0c\n\x05\x04\n\x02\0\x01\x12\x03<\x18%\n\x0c\n\x05\x04\n\x02\0\
    \x03\x12\x03<()\n\x0b\n\x04\x04\n\x02\x01\x12\x03=\x08,\n\x0c\n\x05\x04\
    \n\x02\x01\x04\x12\x03=\x08\x10\n\x0c\n\x05\x04\n\x02\x01\x05\x12\x03=\
    \x11\x17\n\x0c\n\x05\x04\n\x02\x01\x01\x12\x03=\x18'\n\x0c\n\x05\x04\n\
    \x02\x01\x03\x12\x03=*+\n\x0b\n\x04\x04\n\x02\x02\x12\x03>\x08&\n\x0c\n\
    \x05\x04\n\x02\x02\x04\x12\x03>\x08\x10\n\x0c\n\x05\x04\n\x02\x02\x05\
    \x12\x03>\x11\x17\n\x0c\n\x05\x04\n\x02\x02\x01\x12\x03>\x18!\n\x0c\n\
    \x05\x04\n\x02\x02\x03\x12\x03>$%\n\x0b\n\x04\x04\n\x02\x03\x12\x03?\x08\
    (\n\x0c\n\x05\x04\n\x02\x03\x04\x12\x03?\x08\x10\n\x0c\n\x05\x04\n\x02\
    \x03\x05\x12\x03?\x11\x17\n\x0c\n\x05\x04\n\x02\x03\x01\x12\x03?\x18#\n\
    \x0c\n\x05\x04\n\x02\x03\x03\x12\x03?&'\n\x0b\n\x04\x04\n\x02\x04\x12\
    \x03@\x089\n\x0c\n\x05\x04\n\x02\x04\x04\x12\x03@\x08\x10\n\x0c\n\x05\
    \x04\n\x02\x04\x05\x12\x03@\x11\x16\n\x0c\n\x05\x04\n\x02\x04\x01\x12\
    \x03@\x17&\n\x0c\n\x05\x04\n\x02\x04\x03\x12\x03@)*\n\x0c\n\x05\x04\n\
    \x02\x04\x08\x12\x03@+8\n\x0c\n\x05\x04\n\x02\x04\x07\x12\x03@67\n\x0b\n\
    \x04\x04\n\x02\x05\x12\x03A\x08A\n\x0c\n\x05\x04\n\x02\x05\x04\x12\x03A\
    \x08\x10\n\x0c\n\x05\x04\n\x02\x05\x05\x12\x03A\x11\x15\n\x0c\n\x05\x04\
    \n\x02\x05\x01\x12\x03A\x16*\n\x0c\n\x05\x04\n\x02\x05\x03\x12\x03A-.\n\
    \x0c\n\x05\x04\n\x02\x05\x08\x12\x03A/@\n\x0c\n\x05\x04\n\x02\x05\x07\
    \x12\x03A:?\n\n\n\x02\x04\x0b\x12\x04D\0I\x01\n\n\n\x03\x04\x0b\x01\x12\
    \x03D\x08B\n\x0b\n\x04\x04\x0b\x02\0\x12\x03E\x08(\n\x0c\n\x05\x04\x0b\
    \x02\0\x04\x12\x03E\x08\x10\n\x0c\n\x05\x04\x0b\x02\0\x05\x12\x03E\x11\
    \x17\n\x0c\n\x05\x04\x0b\x02\0\x01\x12\x03E\x18#\n\x0c\n\x05\x04\x0b\x02\
    \0\x03\x12\x03E&'\n\x0b\n\x04\x04\x0b\x02\x01\x12\x03F\x08,\n\x0c\n\x05\
    \x04\x0b\x02\x01\x04\x12\x03F\x08\x10\n\x0c\n\x05\x04\x0b\x02\x01\x05\
    \x12\x03F\x11\x17\n\x0c\n\x05\x04\x0b\x02\x01\x01\x12\x03F\x18'\n\x0c\n\
    \x05\x04\x0b\x02\x01\x03\x12\x03F*+\n\x0b\n\x04\x04\x0b\x02\x02\x12\x03G\
    \x08)\n\x0c\n\x05\x04\x0b\x02\x02\x04\x12\x03G\x08\x10\n\x0c\n\x05\x04\
    \x0b\x02\x02\x05\x12\x03G\x11\x17\n\x0c\n\x05\x04\x0b\x02\x02\x01\x12\
    \x03G\x18$\n\x0c\n\x05\x04\x0b\x02\x02\x03\x12\x03G'(\n\x0b\n\x04\x04\
    \x0b\x02\x03\x12\x03H\x08*\n\x0c\n\x05\x04\x0b\x02\x03\x04\x12\x03H\x08\
    \x10\n\x0c\n\x05\x04\x0b\x02\x03\x05\x12\x03H\x11\x17\n\x0c\n\x05\x04\
    \x0b\x02\x03\x01\x12\x03H\x18%\n\x0c\n\x05\x04\x0b\x02\x03\x03\x12\x03H(\
    )\n\n\n\x02\x04\x0c\x12\x04K\0M\x01\n\n\n\x03\x04\x0c\x01\x12\x03K\x08:\
    \n\x0b\n\x04\x04\x0c\x02\0\x12\x03L\x08`\n\x0c\n\x05\x04\x0c\x02\0\x04\
    \x12\x03L\x08\x10\n\x0c\n\x05\x04\x0c\x02\0\x06\x12\x03L\x11L\n\x0c\n\
    \x05\x04\x0c\x02\0\x01\x12\x03LM[\n\x0c\n\x05\x04\x0c\x02\0\x03\x12\x03L\
    ^_\n\n\n\x02\x04\r\x12\x04O\0S\x01\n\n\n\x03\x04\r\x01\x12\x03O\x08:\n\
    \x0b\n\x04\x04\r\x02\0\x12\x03P\x08*\n\x0c\n\x05\x04\r\x02\0\x04\x12\x03\
    P\x08\x10\n\x0c\n\x05\x04\r\x02\0\x05\x12\x03P\x11\x17\n\x0c\n\x05\x04\r\
    \x02\0\x01\x12\x03P\x18%\n\x0c\n\x05\x04\r\x02\0\x03\x12\x03P()\n\x0b\n\
    \x04\x04\r\x02\x01\x12\x03Q\x08,\n\x0c\n\x05\x04\r\x02\x01\x04\x12\x03Q\
    \x08\x10\n\x0c\n\x05\x04\r\x02\x01\x05\x12\x03Q\x11\x17\n\x0c\n\x05\x04\
    \r\x02\x01\x01\x12\x03Q\x18'\n\x0c\n\x05\x04\r\x02\x01\x03\x12\x03Q*+\n\
    \x0b\n\x04\x04\r\x02\x02\x12\x03R\x08&\n\x0c\n\x05\x04\r\x02\x02\x04\x12\
    \x03R\x08\x10\n\x0c\n\x05\x04\r\x02\x02\x05\x12\x03R\x11\x17\n\x0c\n\x05\
    \x04\r\x02\x02\x01\x12\x03R\x18!\n\x0c\n\x05\x04\r\x02\x02\x03\x12\x03R$\
    %\n\n\n\x02\x04\x0e\x12\x04U\0V\x01\n\n\n\x03\x04\x0e\x01\x12\x03U\x08;\
    \n\n\n\x02\x04\x0f\x12\x04X\0\\\x01\n\n\n\x03\x04\x0f\x01\x12\x03X\x087\
    \n\x0b\n\x04\x04\x0f\x02\0\x12\x03Y\x08*\n\x0c\n\x05\x04\x0f\x02\0\x04\
    \x12\x03Y\x08\x10\n\x0c\n\x05\x04\x0f\x02\0\x05\x12\x03Y\x11\x17\n\x0c\n\
    \x05\x04\x0f\x02\0\x01\x12\x03Y\x18%\n\x0c\n\x05\x04\x0f\x02\0\x03\x12\
    \x03Y()\n\x0b\n\x04\x04\x0f\x02\x01\x12\x03Z\x08,\n\x0c\n\x05\x04\x0f\
    \x02\x01\x04\x12\x03Z\x08\x10\n\x0c\n\x05\x04\x0f\x02\x01\x05\x12\x03Z\
    \x11\x17\n\x0c\n\x05\x04\x0f\x02\x01\x01\x12\x03Z\x18'\n\x0c\n\x05\x04\
    \x0f\x02\x01\x03\x12\x03Z*+\n\x0b\n\x04\x04\x0f\x02\x02\x12\x03[\x08&\n\
    \x0c\n\x05\x04\x0f\x02\x02\x04\x12\x03[\x08\x10\n\x0c\n\x05\x04\x0f\x02\
    \x02\x05\x12\x03[\x11\x17\n\x0c\n\x05\x04\x0f\x02\x02\x01\x12\x03[\x18!\
    \n\x0c\n\x05\x04\x0f\x02\x02\x03\x12\x03[$%\n\n\n\x02\x04\x10\x12\x04^\0\
    _\x01\n\n\n\x03\x04\x10\x01\x12\x03^\x088\n\n\n\x02\x04\x11\x12\x04a\0d\
    \x01\n\n\n\x03\x04\x11\x01\x12\x03a\x087\n\x0b\n\x04\x04\x11\x02\0\x12\
    \x03b\x08*\n\x0c\n\x05\x04\x11\x02\0\x04\x12\x03b\x08\x10\n\x0c\n\x05\
    \x04\x11\x02\0\x05\x12\x03b\x11\x17\n\x0c\n\x05\x04\x11\x02\0\x01\x12\
    \x03b\x18%\n\x0c\n\x05\x04\x11\x02\0\x03\x12\x03b()\n\x0b\n\x04\x04\x11\
    \x02\x01\x12\x03c\x08&\n\x0c\n\x05\x04\x11\x02\x01\x04\x12\x03c\x08\x10\
    \n\x0c\n\x05\x04\x11\x02\x01\x05\x12\x03c\x11\x17\n\x0c\n\x05\x04\x11\
    \x02\x01\x01\x12\x03c\x18!\n\x0c\n\x05\x04\x11\x02\x01\x03\x12\x03c$%\n\
    \n\n\x02\x04\x12\x12\x04f\0h\x01\n\n\n\x03\x04\x12\x01\x12\x03f\x088\n\
    \x0b\n\x04\x04\x12\x02\0\x12\x03g\x08,\n\x0c\n\x05\x04\x12\x02\0\x04\x12\
    \x03g\x08\x10\n\x0c\n\x05\x04\x12\x02\0\x05\x12\x03g\x11\x17\n\x0c\n\x05\
    \x04\x12\x02\0\x01\x12\x03g\x18'\n\x0c\n\x05\x04\x12\x02\0\x03\x12\x03g*\
    +\n\n\n\x02\x04\x13\x12\x04j\0r\x01\n\n\n\x03\x04\x13\x01\x12\x03j\x085\
    \n\x0c\n\x04\x04\x13\x03\0\x12\x04k\x08n\t\n\x0c\n\x05\x04\x13\x03\0\x01\
    \x12\x03k\x10\x14\n\r\n\x06\x04\x13\x03\0\x02\0\x12\x03l\x10(\n\x0e\n\
    \x07\x04\x13\x03\0\x02\0\x04\x12\x03l\x10\x18\n\x0e\n\x07\x04\x13\x03\0\
    \x02\0\x05\x12\x03l\x19\x1f\n\x0e\n\x07\x04\x13\x03\0\x02\0\x01\x12\x03l\
    \x20#\n\x0e\n\x07\x04\x13\x03\0\x02\0\x03\x12\x03l&'\n\r\n\x06\x04\x13\
    \x03\0\x02\x01\x12\x03m\x10*\n\x0e\n\x07\x04\x13\x03\0\x02\x01\x04\x12\
    \x03m\x10\x18\n\x0e\n\x07\x04\x13\x03\0\x02\x01\x05\x12\x03m\x19\x1f\n\
    \x0e\n\x07\x04\x13\x03\0\x02\x01\x01\x12\x03m\x20%\n\x0e\n\x07\x04\x13\
    \x03\0\x02\x01\x03\x12\x03m()\n\x0b\n\x04\x04\x13\x02\0\x12\x03p\x08\\\n\
    \x0c\n\x05\x04\x13\x02\0\x04\x12\x03p\x08\x10\n\x0c\n\x05\x04\x13\x02\0\
    \x05\x12\x03p\x11\x17\n\x0c\n\x05\x04\x13\x02\0\x01\x12\x03p\x18$\n\x0c\
    \n\x05\x04\x13\x02\0\x03\x12\x03p'(\n\x0c\n\x05\x04\x13\x02\0\x08\x12\
    \x03p)[\n\x0f\n\x08\x04\x13\x02\0\x08\xd0\x86\x03\x12\x03p*Z\n\x0c\n\x04\
    \x04\x13\x02\x01\x12\x04q\x08\x84\x01\n\x0c\n\x05\x04\x13\x02\x01\x04\
    \x12\x03q\x08\x10\n\x0c\n\x05\x04\x13\x02\x01\x06\x12\x03q\x11D\n\x0c\n\
    \x05\x04\x13\x02\x01\x01\x12\x03qEK\n\x0c\n\x05\x04\x13\x02\x01\x03\x12\
    \x03qNO\n\r\n\x05\x04\x13\x02\x01\x08\x12\x04qP\x83\x01\n\x10\n\x08\x04\
    \x13\x02\x01\x08\xd0\x86\x03\x12\x04qQ\x82\x01\n\x0b\n\x02\x04\x14\x12\
    \x05t\0\x82\x01\x01\n\n\n\x03\x04\x14\x01\x12\x03t\x086\n\x0c\n\x04\x04\
    \x14\x03\0\x12\x04u\x08x\t\n\x0c\n\x05\x04\x14\x03\0\x01\x12\x03u\x10\
    \x14\n\r\n\x06\x04\x14\x03\0\x02\0\x12\x03v\x10(\n\x0e\n\x07\x04\x14\x03\
    \0\x02\0\x04\x12\x03v\x10\x18\n\x0e\n\x07\x04\x14\x03\0\x02\0\x05\x12\
    \x03v\x19\x1f\n\x0e\n\x07\x04\x14\x03\0\x02\0\x01\x12\x03v\x20#\n\x0e\n\
    \x07\x04\x14\x03\0\x02\0\x03\x12\x03v&'\n\r\n\x06\x04\x14\x03\0\x02\x01\
    \x12\x03w\x10*\n\x0e\n\x07\x04\x14\x03\0\x02\x01\x04\x12\x03w\x10\x18\n\
    \x0e\n\x07\x04\x14\x03\0\x02\x01\x05\x12\x03w\x19\x1f\n\x0e\n\x07\x04\
    \x14\x03\0\x02\x01\x01\x12\x03w\x20%\n\x0e\n\x07\x04\x14\x03\0\x02\x01\
    \x03\x12\x03w()\n\x0c\n\x04\x04\x14\x03\x01\x12\x04z\x08~\t\n\x0c\n\x05\
    \x04\x14\x03\x01\x01\x12\x03z\x10\x20\n\r\n\x06\x04\x14\x03\x01\x02\0\
    \x12\x03{\x10d\n\x0e\n\x07\x04\x14\x03\x01\x02\0\x04\x12\x03{\x10\x18\n\
    \x0e\n\x07\x04\x14\x03\x01\x02\0\x05\x12\x03{\x19\x1f\n\x0e\n\x07\x04\
    \x14\x03\x01\x02\0\x01\x12\x03{\x20$\n\x0e\n\x07\x04\x14\x03\x01\x02\0\
    \x03\x12\x03{'(\n\x0e\n\x07\x04\x14\x03\x01\x02\0\x08\x12\x03{)c\n\x11\n\
    \n\x04\x14\x03\x01\x02\0\x08\xd0\x86\x03\x12\x03{*b\n\r\n\x06\x04\x14\
    \x03\x01\x02\x01\x12\x03|\x10R\n\x0e\n\x07\x04\x14\x03\x01\x02\x01\x04\
    \x12\x03|\x10\x18\n\x0e\n\x07\x04\x14\x03\x01\x02\x01\x05\x12\x03|\x19\
    \x1f\n\x0e\n\x07\x04\x14\x03\x01\x02\x01\x01\x12\x03|\x20%\n\x0e\n\x07\
    \x04\x14\x03\x01\x02\x01\x03\x12\x03|()\n\x0e\n\x07\x04\x14\x03\x01\x02\
    \x01\x08\x12\x03|*Q\n\x11\n\n\x04\x14\x03\x01\x02\x01\x08\xd0\x86\x03\
    \x12\x03|+P\n\r\n\x06\x04\x14\x03\x01\x02\x02\x12\x03}\x10U\n\x0e\n\x07\
    \x04\x14\x03\x01\x02\x02\x04\x12\x03}\x10\x18\n\x0e\n\x07\x04\x14\x03\
    \x01\x02\x02\x05\x12\x03}\x19\x1f\n\x0e\n\x07\x04\x14\x03\x01\x02\x02\
    \x01\x12\x03}\x20%\n\x0e\n\x07\x04\x14\x03\x01\x02\x02\x03\x12\x03}()\n\
    \x0e\n\x07\x04\x14\x03\x01\x02\x02\x08\x12\x03}*T\n\x11\n\n\x04\x14\x03\
    \x01\x02\x02\x08\xd0\x86\x03\x12\x03}+S\n\r\n\x04\x04\x14\x02\0\x12\x05\
    \x80\x01\x08\x89\x01\n\r\n\x05\x04\x14\x02\0\x04\x12\x04\x80\x01\x08\x10\
    \n\r\n\x05\x04\x14\x02\0\x06\x12\x04\x80\x01\x11E\n\r\n\x05\x04\x14\x02\
    \0\x01\x12\x04\x80\x01FL\n\r\n\x05\x04\x14\x02\0\x03\x12\x04\x80\x01OP\n\
    \x0e\n\x05\x04\x14\x02\0\x08\x12\x05\x80\x01Q\x88\x01\n\x11\n\x08\x04\
    \x14\x02\0\x08\xd0\x86\x03\x12\x05\x80\x01R\x87\x01\n\r\n\x04\x04\x14\
    \x02\x01\x12\x05\x81\x01\x08\x90\x01\n\r\n\x05\x04\x14\x02\x01\x04\x12\
    \x04\x81\x01\x08\x10\n\r\n\x05\x04\x14\x02\x01\x06\x12\x04\x81\x01\x11Q\
    \n\r\n\x05\x04\x14\x02\x01\x01\x12\x04\x81\x01R\\\n\r\n\x05\x04\x14\x02\
    \x01\x03\x12\x04\x81\x01_`\n\x0e\n\x05\x04\x14\x02\x01\x08\x12\x05\x81\
    \x01a\x8f\x01\n\x11\n\x08\x04\x14\x02\x01\x08\xd0\x86\x03\x12\x05\x81\
    \x01b\x8e\x01\n\x0c\n\x02\x04\x15\x12\x06\x84\x01\0\x8a\x01\x01\n\x0b\n\
    \x03\x04\x15\x01\x12\x04\x84\x01\x08<\n\x0c\n\x04\x04\x15\x02\0\x12\x04\
    \x85\x01\x08*\n\r\n\x05\x04\x15\x02\0\x04\x12\x04\x85\x01\x08\x10\n\r\n\
    \x05\x04\x15\x02\0\x05\x12\x04\x85\x01\x11\x17\n\r\n\x05\x04\x15\x02\0\
    \x01\x12\x04\x85\x01\x18%\n\r\n\x05\x04\x15\x02\0\x03\x12\x04\x85\x01()\
    \n\x0c\n\x04\x04\x15\x02\x01\x12\x04\x86\x01\x087\n\r\n\x05\x04\x15\x02\
    \x01\x04\x12\x04\x86\x01\x08\x10\n\r\n\x05\x04\x15\x02\x01\x05\x12\x04\
    \x86\x01\x11\x17\n\r\n\x05\x04\x15\x02\x01\x01\x12\x04\x86\x01\x182\n\r\
    \n\x05\x04\x15\x02\x01\x03\x12\x04\x86\x0156\n\x0c\n\x04\x04\x15\x02\x02\
    \x12\x04\x87\x01\x08+\n\r\n\x05\x04\x15\x02\x02\x04\x12\x04\x87\x01\x08\
    \x10\n\r\n\x05\x04\x15\x02\x02\x05\x12\x04\x87\x01\x11\x17\n\r\n\x05\x04\
    \x15\x02\x02\x01\x12\x04\x87\x01\x18&\n\r\n\x05\x04\x15\x02\x02\x03\x12\
    \x04\x87\x01)*\n\x0c\n\x04\x04\x15\x02\x03\x12\x04\x88\x01\x08d\n\r\n\
    \x05\x04\x15\x02\x03\x04\x12\x04\x88\x01\x08\x10\n\r\n\x05\x04\x15\x02\
    \x03\x06\x12\x04\x88\x01\x11&\n\r\n\x05\x04\x15\x02\x03\x01\x12\x04\x88\
    \x01'5\n\r\n\x05\x04\x15\x02\x03\x03\x12\x04\x88\x0189\n\r\n\x05\x04\x15\
    \x02\x03\x08\x12\x04\x88\x01:c\n\r\n\x05\x04\x15\x02\x03\x07\x12\x04\x88\
    \x01Eb\n\x0c\n\x04\x04\x15\x02\x04\x12\x04\x89\x01\x085\n\r\n\x05\x04\
    \x15\x02\x04\x04\x12\x04\x89\x01\x08\x10\n\r\n\x05\x04\x15\x02\x04\x05\
    \x12\x04\x89\x01\x11\x16\n\r\n\x05\x04\x15\x02\x04\x01\x12\x04\x89\x01\
    \x170\n\r\n\x05\x04\x15\x02\x04\x03\x12\x04\x89\x0134\n\x0c\n\x02\x04\
    \x16\x12\x06\x8c\x01\0\x8d\x01\x01\n\x0b\n\x03\x04\x16\x01\x12\x04\x8c\
    \x01\x08=\n\x0c\n\x02\x06\0\x12\x06\x8f\x01\0\xb9\x01\x01\n\x0b\n\x03\
    \x06\0\x01\x12\x04\x8f\x01\x08\x17\n\x0b\n\x03\x06\0\x03\x12\x04\x90\x01\
    \x08[\n\x0e\n\x06\x06\0\x03\xd0\x86\x03\x12\x04\x90\x01\x08[\n\x0e\n\x04\
    \x06\0\x02\0\x12\x06\x92\x01\x08\x94\x01\t\n\r\n\x05\x06\0\x02\0\x01\x12\
    \x04\x92\x01\x0c#\n\r\n\x05\x06\0\x02\0\x02\x12\x04\x92\x01%V\n\x0e\n\
    \x05\x06\0\x02\0\x03\x12\x05\x92\x01a\x93\x01\n\x0e\n\x05\x06\0\x02\0\
    \x04\x12\x05\x93\x01\x10\x83\x01\n\x11\n\x08\x06\0\x02\0\x04\xd0\x86\x03\
    \x12\x05\x93\x01\x10\x83\x01\n\x0e\n\x04\x06\0\x02\x01\x12\x06\x96\x01\
    \x08\x98\x01\t\n\r\n\x05\x06\0\x02\x01\x01\x12\x04\x96\x01\x0c/\n\r\n\
    \x05\x06\0\x02\x01\x02\x12\x04\x96\x011n\n\x0e\n\x05\x06\0\x02\x01\x03\
    \x12\x05\x96\x01y\xb7\x01\n\r\n\x05\x06\0\x02\x01\x04\x12\x04\x97\x01\
    \x10^\n\x10\n\x08\x06\0\x02\x01\x04\xd0\x86\x03\x12\x04\x97\x01\x10^\n\
    \x0e\n\x04\x06\0\x02\x02\x12\x06\x9a\x01\x08\x9c\x01\t\n\r\n\x05\x06\0\
    \x02\x02\x01\x12\x04\x9a\x01\x0c/\n\r\n\x05\x06\0\x02\x02\x02\x12\x04\
    \x9a\x011j\n\x0e\n\x05\x06\0\x02\x02\x03\x12\x05\x9a\x01u\xaf\x01\n\r\n\
    \x05\x06\0\x02\x02\x04\x12\x04\x9b\x01\x10j\n\x10\n\x08\x06\0\x02\x02\
    \x04\xd0\x86\x03\x12\x04\x9b\x01\x10j\n\x0e\n\x04\x06\0\x02\x03\x12\x06\
    \x9e\x01\x08\xa0\x01\t\n\r\n\x05\x06\0\x02\x03\x01\x12\x04\x9e\x01\x0c,\
    \n\r\n\x05\x06\0\x02\x03\x02\x12\x04\x9e\x01.`\n\x0e\n\x05\x06\0\x02\x03\
    \x03\x12\x05\x9e\x01k\x9e\x01\n\r\n\x05\x06\0\x02\x03\x04\x12\x04\x9f\
    \x01\x10\\\n\x10\n\x08\x06\0\x02\x03\x04\xd0\x86\x03\x12\x04\x9f\x01\x10\
    \\\n\x0e\n\x04\x06\0\x02\x04\x12\x06\xa2\x01\x08\xa4\x01\t\n\r\n\x05\x06\
    \0\x02\x04\x01\x12\x04\xa2\x01\x0c,\n\r\n\x05\x06\0\x02\x04\x02\x12\x04\
    \xa2\x01.`\n\x0e\n\x05\x06\0\x02\x04\x03\x12\x05\xa2\x01k\x9e\x01\n\r\n\
    \x05\x06\0\x02\x04\x04\x12\x04\xa3\x01\x10\\\n\x10\n\x08\x06\0\x02\x04\
    \x04\xd0\x86\x03\x12\x04\xa3\x01\x10\\\n\x0e\n\x04\x06\0\x02\x05\x12\x06\
    \xa6\x01\x08\xa8\x01\t\n\r\n\x05\x06\0\x02\x05\x01\x12\x04\xa6\x01\x0c%\
    \n\r\n\x05\x06\0\x02\x05\x02\x12\x04\xa6\x01'Z\n\x0e\n\x05\x06\0\x02\x05\
    \x03\x12\x05\xa6\x01e\x99\x01\n\r\n\x05\x06\0\x02\x05\x04\x12\x04\xa7\
    \x01\x10J\n\x10\n\x08\x06\0\x02\x05\x04\xd0\x86\x03\x12\x04\xa7\x01\x10J\
    \n\x0e\n\x04\x06\0\x02\x06\x12\x06\xaa\x01\x08\xac\x01\t\n\r\n\x05\x06\0\
    \x02\x06\x01\x12\x04\xaa\x01\x0c,\n\r\n\x05\x06\0\x02\x06\x02\x12\x04\
    \xaa\x01.^\n\x0e\n\x05\x06\0\x02\x06\x03\x12\x05\xaa\x01i\x9a\x01\n\r\n\
    \x05\x06\0\x02\x06\x04\x12\x04\xab\x01\x10_\n\x10\n\x08\x06\0\x02\x06\
    \x04\xd0\x86\x03\x12\x04\xab\x01\x10_\n\x0e\n\x04\x06\0\x02\x07\x12\x06\
    \xae\x01\x08\xb0\x01\t\n\r\n\x05\x06\0\x02\x07\x01\x12\x04\xae\x01\x0c,\
    \n\r\n\x05\x06\0\x02\x07\x02\x12\x04\xae\x01.^\n\x0e\n\x05\x06\0\x02\x07\
    \x03\x12\x05\xae\x01i\x9a\x01\n\r\n\x05\x06\0\x02\x07\x04\x12\x04\xaf\
    \x01\x10]\n\x10\n\x08\x06\0\x02\x07\x04\xd0\x86\x03\x12\x04\xaf\x01\x10]\
    \n\x0e\n\x04\x06\0\x02\x08\x12\x06\xb2\x01\x08\xb4\x01\t\n\r\n\x05\x06\0\
    \x02\x08\x01\x12\x04\xb2\x01\x0c\x20\n\r\n\x05\x06\0\x02\x08\x02\x12\x04\
    \xb2\x01\"P\n\x0e\n\x05\x06\0\x02\x08\x03\x12\x05\xb2\x01[\x8a\x01\n\r\n\
    \x05\x06\0\x02\x08\x04\x12\x04\xb3\x01\x10\\\n\x10\n\x08\x06\0\x02\x08\
    \x04\xd0\x86\x03\x12\x04\xb3\x01\x10\\\n\x0e\n\x04\x06\0\x02\t\x12\x06\
    \xb6\x01\x08\xb8\x01\t\n\r\n\x05\x06\0\x02\t\x01\x12\x04\xb6\x01\x0c'\n\
    \r\n\x05\x06\0\x02\t\x02\x12\x04\xb6\x01)^\n\x0e\n\x05\x06\0\x02\t\x03\
    \x12\x05\xb6\x01i\x9f\x01\n\r\n\x05\x06\0\x02\t\x04\x12\x04\xb7\x01\x10`\
    \n\x10\n\x08\x06\0\x02\t\x04\xd0\x86\x03\x12\x04\xb7\x01\x10`\
";

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()
    })
}