// This file is generated by rust-protobuf 3.5.1. Do not edit
// .proto file is parsed by pure
// @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(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]

//! Generated file from `steammessages_virtualcontroller.proto`
// Generated for lite runtime

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

// @@protoc_insertion_point(message:CVirtualControllerElement)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVirtualControllerElement {
    // message fields
    // @@protoc_insertion_point(field:CVirtualControllerElement.type)
    pub type_: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<EControllerElementType>>,
    // @@protoc_insertion_point(field:CVirtualControllerElement.visible)
    pub visible: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CVirtualControllerElement.x_position)
    pub x_position: ::std::option::Option<f32>,
    // @@protoc_insertion_point(field:CVirtualControllerElement.y_position)
    pub y_position: ::std::option::Option<f32>,
    // @@protoc_insertion_point(field:CVirtualControllerElement.x_scale)
    pub x_scale: ::std::option::Option<f32>,
    // @@protoc_insertion_point(field:CVirtualControllerElement.y_scale)
    pub y_scale: ::std::option::Option<f32>,
    // special fields
    // @@protoc_insertion_point(special_field:CVirtualControllerElement.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional .EControllerElementType type = 1;

    pub fn type_(&self) -> EControllerElementType {
        match self.type_ {
            Some(e) => e.enum_value_or(EControllerElementType::k_EControllerElementTypeNone),
            None => EControllerElementType::k_EControllerElementTypeNone,
        }
    }

    pub fn clear_type_(&mut self) {
        self.type_ = ::std::option::Option::None;
    }

    pub fn has_type(&self) -> bool {
        self.type_.is_some()
    }

    // Param is passed by value, moved
    pub fn set_type(&mut self, v: EControllerElementType) {
        self.type_ = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional bool visible = 2;

    pub fn visible(&self) -> bool {
        self.visible.unwrap_or(false)
    }

    pub fn clear_visible(&mut self) {
        self.visible = ::std::option::Option::None;
    }

    pub fn has_visible(&self) -> bool {
        self.visible.is_some()
    }

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

    // optional float x_position = 3;

    pub fn x_position(&self) -> f32 {
        self.x_position.unwrap_or(0.)
    }

    pub fn clear_x_position(&mut self) {
        self.x_position = ::std::option::Option::None;
    }

    pub fn has_x_position(&self) -> bool {
        self.x_position.is_some()
    }

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

    // optional float y_position = 4;

    pub fn y_position(&self) -> f32 {
        self.y_position.unwrap_or(0.)
    }

    pub fn clear_y_position(&mut self) {
        self.y_position = ::std::option::Option::None;
    }

    pub fn has_y_position(&self) -> bool {
        self.y_position.is_some()
    }

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

    // optional float x_scale = 5;

    pub fn x_scale(&self) -> f32 {
        self.x_scale.unwrap_or(1.0f32)
    }

    pub fn clear_x_scale(&mut self) {
        self.x_scale = ::std::option::Option::None;
    }

    pub fn has_x_scale(&self) -> bool {
        self.x_scale.is_some()
    }

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

    // optional float y_scale = 6;

    pub fn y_scale(&self) -> f32 {
        self.y_scale.unwrap_or(1.0f32)
    }

    pub fn clear_y_scale(&mut self) {
        self.y_scale = ::std::option::Option::None;
    }

    pub fn has_y_scale(&self) -> bool {
        self.y_scale.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CVirtualControllerElement {
    const NAME: &'static str = "CVirtualControllerElement";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.type_ = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                16 => {
                    self.visible = ::std::option::Option::Some(is.read_bool()?);
                },
                29 => {
                    self.x_position = ::std::option::Option::Some(is.read_float()?);
                },
                37 => {
                    self.y_position = ::std::option::Option::Some(is.read_float()?);
                },
                45 => {
                    self.x_scale = ::std::option::Option::Some(is.read_float()?);
                },
                53 => {
                    self.y_scale = ::std::option::Option::Some(is.read_float()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.type_ {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v.value());
        }
        if let Some(v) = self.visible {
            my_size += 1 + 1;
        }
        if let Some(v) = self.x_position {
            my_size += 1 + 4;
        }
        if let Some(v) = self.y_position {
            my_size += 1 + 4;
        }
        if let Some(v) = self.x_scale {
            my_size += 1 + 4;
        }
        if let Some(v) = self.y_scale {
            my_size += 1 + 4;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.type_ {
            os.write_enum(1, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.visible {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.x_position {
            os.write_float(3, v)?;
        }
        if let Some(v) = self.y_position {
            os.write_float(4, v)?;
        }
        if let Some(v) = self.x_scale {
            os.write_float(5, v)?;
        }
        if let Some(v) = self.y_scale {
            os.write_float(6, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.type_ = ::std::option::Option::None;
        self.visible = ::std::option::Option::None;
        self.x_position = ::std::option::Option::None;
        self.y_position = ::std::option::Option::None;
        self.x_scale = ::std::option::Option::None;
        self.y_scale = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CVirtualControllerElement {
        static instance: CVirtualControllerElement = CVirtualControllerElement {
            type_: ::std::option::Option::None,
            visible: ::std::option::Option::None,
            x_position: ::std::option::Option::None,
            y_position: ::std::option::Option::None,
            x_scale: ::std::option::Option::None,
            y_scale: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CVirtualControllerColor)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVirtualControllerColor {
    // message fields
    // @@protoc_insertion_point(field:CVirtualControllerColor.r)
    pub r: ::std::option::Option<f32>,
    // @@protoc_insertion_point(field:CVirtualControllerColor.g)
    pub g: ::std::option::Option<f32>,
    // @@protoc_insertion_point(field:CVirtualControllerColor.b)
    pub b: ::std::option::Option<f32>,
    // @@protoc_insertion_point(field:CVirtualControllerColor.a)
    pub a: ::std::option::Option<f32>,
    // special fields
    // @@protoc_insertion_point(special_field:CVirtualControllerColor.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional float r = 1;

    pub fn r(&self) -> f32 {
        self.r.unwrap_or(1.0f32)
    }

    pub fn clear_r(&mut self) {
        self.r = ::std::option::Option::None;
    }

    pub fn has_r(&self) -> bool {
        self.r.is_some()
    }

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

    // optional float g = 2;

    pub fn g(&self) -> f32 {
        self.g.unwrap_or(1.0f32)
    }

    pub fn clear_g(&mut self) {
        self.g = ::std::option::Option::None;
    }

    pub fn has_g(&self) -> bool {
        self.g.is_some()
    }

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

    // optional float b = 3;

    pub fn b(&self) -> f32 {
        self.b.unwrap_or(1.0f32)
    }

    pub fn clear_b(&mut self) {
        self.b = ::std::option::Option::None;
    }

    pub fn has_b(&self) -> bool {
        self.b.is_some()
    }

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

    // optional float a = 4;

    pub fn a(&self) -> f32 {
        self.a.unwrap_or(1.0f32)
    }

    pub fn clear_a(&mut self) {
        self.a = ::std::option::Option::None;
    }

    pub fn has_a(&self) -> bool {
        self.a.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CVirtualControllerColor {
    const NAME: &'static str = "CVirtualControllerColor";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                13 => {
                    self.r = ::std::option::Option::Some(is.read_float()?);
                },
                21 => {
                    self.g = ::std::option::Option::Some(is.read_float()?);
                },
                29 => {
                    self.b = ::std::option::Option::Some(is.read_float()?);
                },
                37 => {
                    self.a = ::std::option::Option::Some(is.read_float()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.r {
            my_size += 1 + 4;
        }
        if let Some(v) = self.g {
            my_size += 1 + 4;
        }
        if let Some(v) = self.b {
            my_size += 1 + 4;
        }
        if let Some(v) = self.a {
            my_size += 1 + 4;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.r {
            os.write_float(1, v)?;
        }
        if let Some(v) = self.g {
            os.write_float(2, v)?;
        }
        if let Some(v) = self.b {
            os.write_float(3, v)?;
        }
        if let Some(v) = self.a {
            os.write_float(4, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.r = ::std::option::Option::None;
        self.g = ::std::option::Option::None;
        self.b = ::std::option::Option::None;
        self.a = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CVirtualControllerColor {
        static instance: CVirtualControllerColor = CVirtualControllerColor {
            r: ::std::option::Option::None,
            g: ::std::option::Option::None,
            b: ::std::option::Option::None,
            a: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CVirtualControllerLayout)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVirtualControllerLayout {
    // message fields
    // @@protoc_insertion_point(field:CVirtualControllerLayout.layout_version)
    pub layout_version: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CVirtualControllerLayout.actionset_id)
    pub actionset_id: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CVirtualControllerLayout.elements)
    pub elements: ::std::vec::Vec<CVirtualControllerElement>,
    // @@protoc_insertion_point(field:CVirtualControllerLayout.color)
    pub color: ::steam_vent_proto_common::protobuf::MessageField<CVirtualControllerColor>,
    // special fields
    // @@protoc_insertion_point(special_field:CVirtualControllerLayout.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional int32 layout_version = 1;

    pub fn layout_version(&self) -> i32 {
        self.layout_version.unwrap_or(0)
    }

    pub fn clear_layout_version(&mut self) {
        self.layout_version = ::std::option::Option::None;
    }

    pub fn has_layout_version(&self) -> bool {
        self.layout_version.is_some()
    }

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

    // optional int32 actionset_id = 2;

    pub fn actionset_id(&self) -> i32 {
        self.actionset_id.unwrap_or(0)
    }

    pub fn clear_actionset_id(&mut self) {
        self.actionset_id = ::std::option::Option::None;
    }

    pub fn has_actionset_id(&self) -> bool {
        self.actionset_id.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CVirtualControllerLayout {
    const NAME: &'static str = "CVirtualControllerLayout";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.layout_version = ::std::option::Option::Some(is.read_int32()?);
                },
                16 => {
                    self.actionset_id = ::std::option::Option::Some(is.read_int32()?);
                },
                34 => {
                    self.elements.push(is.read_message()?);
                },
                42 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.color)?;
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.layout_version {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
        }
        if let Some(v) = self.actionset_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
        }
        for value in &self.elements {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.color.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.layout_version {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.actionset_id {
            os.write_int32(2, v)?;
        }
        for v in &self.elements {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        if let Some(v) = self.color.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.layout_version = ::std::option::Option::None;
        self.actionset_id = ::std::option::Option::None;
        self.elements.clear();
        self.color.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CVirtualControllerLayout {
        static instance: CVirtualControllerLayout = CVirtualControllerLayout {
            layout_version: ::std::option::Option::None,
            actionset_id: ::std::option::Option::None,
            elements: ::std::vec::Vec::new(),
            color: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CVirtualControllerLayouts)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVirtualControllerLayouts {
    // message fields
    // @@protoc_insertion_point(field:CVirtualControllerLayouts.layouts)
    pub layouts: ::std::vec::Vec<CVirtualControllerLayout>,
    // @@protoc_insertion_point(field:CVirtualControllerLayouts.input_mode)
    pub input_mode: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<EInputMode>>,
    // @@protoc_insertion_point(field:CVirtualControllerLayouts.mouse_mode)
    pub mouse_mode: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<EMouseMode>>,
    // @@protoc_insertion_point(field:CVirtualControllerLayouts.trackpad_sensitivity)
    pub trackpad_sensitivity: ::std::option::Option<f32>,
    // @@protoc_insertion_point(field:CVirtualControllerLayouts.pinch_zoom_enabled)
    pub pinch_zoom_enabled: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CVirtualControllerLayouts.pinch_zoom_x)
    pub pinch_zoom_x: ::std::option::Option<f32>,
    // @@protoc_insertion_point(field:CVirtualControllerLayouts.pinch_zoom_y)
    pub pinch_zoom_y: ::std::option::Option<f32>,
    // @@protoc_insertion_point(field:CVirtualControllerLayouts.pinch_zoom_scale)
    pub pinch_zoom_scale: ::std::option::Option<f32>,
    // @@protoc_insertion_point(field:CVirtualControllerLayouts.shaken)
    pub shaken: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CVirtualControllerLayouts.mouse_offscreen)
    pub mouse_offscreen: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CVirtualControllerLayouts.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional .EInputMode input_mode = 2;

    pub fn input_mode(&self) -> EInputMode {
        match self.input_mode {
            Some(e) => e.enum_value_or(EInputMode::k_EInputModeController),
            None => EInputMode::k_EInputModeController,
        }
    }

    pub fn clear_input_mode(&mut self) {
        self.input_mode = ::std::option::Option::None;
    }

    pub fn has_input_mode(&self) -> bool {
        self.input_mode.is_some()
    }

    // Param is passed by value, moved
    pub fn set_input_mode(&mut self, v: EInputMode) {
        self.input_mode = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional .EMouseMode mouse_mode = 3;

    pub fn mouse_mode(&self) -> EMouseMode {
        match self.mouse_mode {
            Some(e) => e.enum_value_or(EMouseMode::k_EMouseModeUnknown),
            None => EMouseMode::k_EMouseModeUnknown,
        }
    }

    pub fn clear_mouse_mode(&mut self) {
        self.mouse_mode = ::std::option::Option::None;
    }

    pub fn has_mouse_mode(&self) -> bool {
        self.mouse_mode.is_some()
    }

    // Param is passed by value, moved
    pub fn set_mouse_mode(&mut self, v: EMouseMode) {
        self.mouse_mode = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional float trackpad_sensitivity = 4;

    pub fn trackpad_sensitivity(&self) -> f32 {
        self.trackpad_sensitivity.unwrap_or(1.0f32)
    }

    pub fn clear_trackpad_sensitivity(&mut self) {
        self.trackpad_sensitivity = ::std::option::Option::None;
    }

    pub fn has_trackpad_sensitivity(&self) -> bool {
        self.trackpad_sensitivity.is_some()
    }

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

    // optional bool pinch_zoom_enabled = 5;

    pub fn pinch_zoom_enabled(&self) -> bool {
        self.pinch_zoom_enabled.unwrap_or(false)
    }

    pub fn clear_pinch_zoom_enabled(&mut self) {
        self.pinch_zoom_enabled = ::std::option::Option::None;
    }

    pub fn has_pinch_zoom_enabled(&self) -> bool {
        self.pinch_zoom_enabled.is_some()
    }

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

    // optional float pinch_zoom_x = 6;

    pub fn pinch_zoom_x(&self) -> f32 {
        self.pinch_zoom_x.unwrap_or(0.0f32)
    }

    pub fn clear_pinch_zoom_x(&mut self) {
        self.pinch_zoom_x = ::std::option::Option::None;
    }

    pub fn has_pinch_zoom_x(&self) -> bool {
        self.pinch_zoom_x.is_some()
    }

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

    // optional float pinch_zoom_y = 7;

    pub fn pinch_zoom_y(&self) -> f32 {
        self.pinch_zoom_y.unwrap_or(0.0f32)
    }

    pub fn clear_pinch_zoom_y(&mut self) {
        self.pinch_zoom_y = ::std::option::Option::None;
    }

    pub fn has_pinch_zoom_y(&self) -> bool {
        self.pinch_zoom_y.is_some()
    }

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

    // optional float pinch_zoom_scale = 8;

    pub fn pinch_zoom_scale(&self) -> f32 {
        self.pinch_zoom_scale.unwrap_or(1.0f32)
    }

    pub fn clear_pinch_zoom_scale(&mut self) {
        self.pinch_zoom_scale = ::std::option::Option::None;
    }

    pub fn has_pinch_zoom_scale(&self) -> bool {
        self.pinch_zoom_scale.is_some()
    }

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

    // optional bool shaken = 9;

    pub fn shaken(&self) -> bool {
        self.shaken.unwrap_or(false)
    }

    pub fn clear_shaken(&mut self) {
        self.shaken = ::std::option::Option::None;
    }

    pub fn has_shaken(&self) -> bool {
        self.shaken.is_some()
    }

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

    // optional bool mouse_offscreen = 10;

    pub fn mouse_offscreen(&self) -> bool {
        self.mouse_offscreen.unwrap_or(false)
    }

    pub fn clear_mouse_offscreen(&mut self) {
        self.mouse_offscreen = ::std::option::Option::None;
    }

    pub fn has_mouse_offscreen(&self) -> bool {
        self.mouse_offscreen.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CVirtualControllerLayouts {
    const NAME: &'static str = "CVirtualControllerLayouts";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.layouts.push(is.read_message()?);
                },
                16 => {
                    self.input_mode = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                24 => {
                    self.mouse_mode = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                37 => {
                    self.trackpad_sensitivity = ::std::option::Option::Some(is.read_float()?);
                },
                40 => {
                    self.pinch_zoom_enabled = ::std::option::Option::Some(is.read_bool()?);
                },
                53 => {
                    self.pinch_zoom_x = ::std::option::Option::Some(is.read_float()?);
                },
                61 => {
                    self.pinch_zoom_y = ::std::option::Option::Some(is.read_float()?);
                },
                69 => {
                    self.pinch_zoom_scale = ::std::option::Option::Some(is.read_float()?);
                },
                72 => {
                    self.shaken = ::std::option::Option::Some(is.read_bool()?);
                },
                80 => {
                    self.mouse_offscreen = ::std::option::Option::Some(is.read_bool()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.layouts {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.input_mode {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v.value());
        }
        if let Some(v) = self.mouse_mode {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v.value());
        }
        if let Some(v) = self.trackpad_sensitivity {
            my_size += 1 + 4;
        }
        if let Some(v) = self.pinch_zoom_enabled {
            my_size += 1 + 1;
        }
        if let Some(v) = self.pinch_zoom_x {
            my_size += 1 + 4;
        }
        if let Some(v) = self.pinch_zoom_y {
            my_size += 1 + 4;
        }
        if let Some(v) = self.pinch_zoom_scale {
            my_size += 1 + 4;
        }
        if let Some(v) = self.shaken {
            my_size += 1 + 1;
        }
        if let Some(v) = self.mouse_offscreen {
            my_size += 1 + 1;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.layouts {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        if let Some(v) = self.input_mode {
            os.write_enum(2, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.mouse_mode {
            os.write_enum(3, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.trackpad_sensitivity {
            os.write_float(4, v)?;
        }
        if let Some(v) = self.pinch_zoom_enabled {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.pinch_zoom_x {
            os.write_float(6, v)?;
        }
        if let Some(v) = self.pinch_zoom_y {
            os.write_float(7, v)?;
        }
        if let Some(v) = self.pinch_zoom_scale {
            os.write_float(8, v)?;
        }
        if let Some(v) = self.shaken {
            os.write_bool(9, v)?;
        }
        if let Some(v) = self.mouse_offscreen {
            os.write_bool(10, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.layouts.clear();
        self.input_mode = ::std::option::Option::None;
        self.mouse_mode = ::std::option::Option::None;
        self.trackpad_sensitivity = ::std::option::Option::None;
        self.pinch_zoom_enabled = ::std::option::Option::None;
        self.pinch_zoom_x = ::std::option::Option::None;
        self.pinch_zoom_y = ::std::option::Option::None;
        self.pinch_zoom_scale = ::std::option::Option::None;
        self.shaken = ::std::option::Option::None;
        self.mouse_offscreen = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CVirtualControllerLayouts {
        static instance: CVirtualControllerLayouts = CVirtualControllerLayouts {
            layouts: ::std::vec::Vec::new(),
            input_mode: ::std::option::Option::None,
            mouse_mode: ::std::option::Option::None,
            trackpad_sensitivity: ::std::option::Option::None,
            pinch_zoom_enabled: ::std::option::Option::None,
            pinch_zoom_x: ::std::option::Option::None,
            pinch_zoom_y: ::std::option::Option::None,
            pinch_zoom_scale: ::std::option::Option::None,
            shaken: ::std::option::Option::None,
            mouse_offscreen: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CVirtualControllerConfig)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVirtualControllerConfig {
    // message fields
    // @@protoc_insertion_point(field:CVirtualControllerConfig.name)
    pub name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CVirtualControllerConfig.actionsets)
    pub actionsets: ::std::vec::Vec<cvirtual_controller_config::ActionSet>,
    // @@protoc_insertion_point(field:CVirtualControllerConfig.default_mouse_mode)
    pub default_mouse_mode: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<EMouseMode>>,
    // special fields
    // @@protoc_insertion_point(special_field:CVirtualControllerConfig.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string name = 1;

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

    pub fn clear_name(&mut self) {
        self.name = ::std::option::Option::None;
    }

    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 = ::std::option::Option::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 = ::std::option::Option::Some(::std::string::String::new());
        }
        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 .EMouseMode default_mouse_mode = 3;

    pub fn default_mouse_mode(&self) -> EMouseMode {
        match self.default_mouse_mode {
            Some(e) => e.enum_value_or(EMouseMode::k_EMouseModeAbsoluteCursor),
            None => EMouseMode::k_EMouseModeAbsoluteCursor,
        }
    }

    pub fn clear_default_mouse_mode(&mut self) {
        self.default_mouse_mode = ::std::option::Option::None;
    }

    pub fn has_default_mouse_mode(&self) -> bool {
        self.default_mouse_mode.is_some()
    }

    // Param is passed by value, moved
    pub fn set_default_mouse_mode(&mut self, v: EMouseMode) {
        self.default_mouse_mode = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CVirtualControllerConfig {
    const NAME: &'static str = "CVirtualControllerConfig";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.name = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.actionsets.push(is.read_message()?);
                },
                24 => {
                    self.default_mouse_mode = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        for value in &self.actionsets {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.default_mouse_mode {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v.value());
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.name.as_ref() {
            os.write_string(1, v)?;
        }
        for v in &self.actionsets {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        if let Some(v) = self.default_mouse_mode {
            os.write_enum(3, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.name = ::std::option::Option::None;
        self.actionsets.clear();
        self.default_mouse_mode = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CVirtualControllerConfig {
        static instance: CVirtualControllerConfig = CVirtualControllerConfig {
            name: ::std::option::Option::None,
            actionsets: ::std::vec::Vec::new(),
            default_mouse_mode: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CVirtualControllerConfig`
pub mod cvirtual_controller_config {
    // @@protoc_insertion_point(message:CVirtualControllerConfig.Control)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Control {
        // message fields
        // @@protoc_insertion_point(field:CVirtualControllerConfig.Control.name)
        pub name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.Control.icon)
        pub icon: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.Control.input_source)
        pub input_source: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.Control.input_mode)
        pub input_mode: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.Control.input_element)
        pub input_element: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.Control.output_gamepad)
        pub output_gamepad: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.Control.output_keyboard)
        pub output_keyboard: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.Control.output_mouse)
        pub output_mouse: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.Control.icon_foreground)
        pub icon_foreground: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.Control.icon_background)
        pub icon_background: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.Control.input_toggle)
        pub input_toggle: ::std::option::Option<bool>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.Control.input_activate_stick_or_trackpad)
        pub input_activate_stick_or_trackpad: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.Control.activation_type)
        pub activation_type: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.Control.long_press_ms)
        pub long_press_ms: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.Control.double_press_ms)
        pub double_press_ms: ::std::option::Option<i32>,
        // special fields
        // @@protoc_insertion_point(special_field:CVirtualControllerConfig.Control.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional string name = 1;

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

        pub fn clear_name(&mut self) {
            self.name = ::std::option::Option::None;
        }

        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 = ::std::option::Option::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 = ::std::option::Option::Some(::std::string::String::new());
            }
            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 icon = 2;

        pub fn icon(&self) -> &str {
            match self.icon.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_icon(&mut self) {
            self.icon = ::std::option::Option::None;
        }

        pub fn has_icon(&self) -> bool {
            self.icon.is_some()
        }

        // Param is passed by value, moved
        pub fn set_icon(&mut self, v: ::std::string::String) {
            self.icon = ::std::option::Option::Some(v);
        }

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

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

        // optional int32 input_source = 3;

        pub fn input_source(&self) -> i32 {
            self.input_source.unwrap_or(0)
        }

        pub fn clear_input_source(&mut self) {
            self.input_source = ::std::option::Option::None;
        }

        pub fn has_input_source(&self) -> bool {
            self.input_source.is_some()
        }

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

        // optional int32 input_mode = 4;

        pub fn input_mode(&self) -> i32 {
            self.input_mode.unwrap_or(0)
        }

        pub fn clear_input_mode(&mut self) {
            self.input_mode = ::std::option::Option::None;
        }

        pub fn has_input_mode(&self) -> bool {
            self.input_mode.is_some()
        }

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

        // optional int32 input_element = 5;

        pub fn input_element(&self) -> i32 {
            self.input_element.unwrap_or(0)
        }

        pub fn clear_input_element(&mut self) {
            self.input_element = ::std::option::Option::None;
        }

        pub fn has_input_element(&self) -> bool {
            self.input_element.is_some()
        }

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

        // optional int32 output_gamepad = 6;

        pub fn output_gamepad(&self) -> i32 {
            self.output_gamepad.unwrap_or(0)
        }

        pub fn clear_output_gamepad(&mut self) {
            self.output_gamepad = ::std::option::Option::None;
        }

        pub fn has_output_gamepad(&self) -> bool {
            self.output_gamepad.is_some()
        }

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

        // optional int32 output_keyboard = 7;

        pub fn output_keyboard(&self) -> i32 {
            self.output_keyboard.unwrap_or(0)
        }

        pub fn clear_output_keyboard(&mut self) {
            self.output_keyboard = ::std::option::Option::None;
        }

        pub fn has_output_keyboard(&self) -> bool {
            self.output_keyboard.is_some()
        }

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

        // optional int32 output_mouse = 8;

        pub fn output_mouse(&self) -> i32 {
            self.output_mouse.unwrap_or(0)
        }

        pub fn clear_output_mouse(&mut self) {
            self.output_mouse = ::std::option::Option::None;
        }

        pub fn has_output_mouse(&self) -> bool {
            self.output_mouse.is_some()
        }

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

        // optional string icon_foreground = 9;

        pub fn icon_foreground(&self) -> &str {
            match self.icon_foreground.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_icon_foreground(&mut self) {
            self.icon_foreground = ::std::option::Option::None;
        }

        pub fn has_icon_foreground(&self) -> bool {
            self.icon_foreground.is_some()
        }

        // Param is passed by value, moved
        pub fn set_icon_foreground(&mut self, v: ::std::string::String) {
            self.icon_foreground = ::std::option::Option::Some(v);
        }

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

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

        // optional string icon_background = 10;

        pub fn icon_background(&self) -> &str {
            match self.icon_background.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_icon_background(&mut self) {
            self.icon_background = ::std::option::Option::None;
        }

        pub fn has_icon_background(&self) -> bool {
            self.icon_background.is_some()
        }

        // Param is passed by value, moved
        pub fn set_icon_background(&mut self, v: ::std::string::String) {
            self.icon_background = ::std::option::Option::Some(v);
        }

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

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

        // optional bool input_toggle = 11;

        pub fn input_toggle(&self) -> bool {
            self.input_toggle.unwrap_or(false)
        }

        pub fn clear_input_toggle(&mut self) {
            self.input_toggle = ::std::option::Option::None;
        }

        pub fn has_input_toggle(&self) -> bool {
            self.input_toggle.is_some()
        }

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

        // optional int32 input_activate_stick_or_trackpad = 12;

        pub fn input_activate_stick_or_trackpad(&self) -> i32 {
            self.input_activate_stick_or_trackpad.unwrap_or(0)
        }

        pub fn clear_input_activate_stick_or_trackpad(&mut self) {
            self.input_activate_stick_or_trackpad = ::std::option::Option::None;
        }

        pub fn has_input_activate_stick_or_trackpad(&self) -> bool {
            self.input_activate_stick_or_trackpad.is_some()
        }

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

        // optional int32 activation_type = 13;

        pub fn activation_type(&self) -> i32 {
            self.activation_type.unwrap_or(0)
        }

        pub fn clear_activation_type(&mut self) {
            self.activation_type = ::std::option::Option::None;
        }

        pub fn has_activation_type(&self) -> bool {
            self.activation_type.is_some()
        }

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

        // optional int32 long_press_ms = 14;

        pub fn long_press_ms(&self) -> i32 {
            self.long_press_ms.unwrap_or(0)
        }

        pub fn clear_long_press_ms(&mut self) {
            self.long_press_ms = ::std::option::Option::None;
        }

        pub fn has_long_press_ms(&self) -> bool {
            self.long_press_ms.is_some()
        }

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

        // optional int32 double_press_ms = 15;

        pub fn double_press_ms(&self) -> i32 {
            self.double_press_ms.unwrap_or(0)
        }

        pub fn clear_double_press_ms(&mut self) {
            self.double_press_ms = ::std::option::Option::None;
        }

        pub fn has_double_press_ms(&self) -> bool {
            self.double_press_ms.is_some()
        }

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

    impl ::steam_vent_proto_common::protobuf::Message for Control {
        const NAME: &'static str = "Control";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.name = ::std::option::Option::Some(is.read_string()?);
                    },
                    18 => {
                        self.icon = ::std::option::Option::Some(is.read_string()?);
                    },
                    24 => {
                        self.input_source = ::std::option::Option::Some(is.read_int32()?);
                    },
                    32 => {
                        self.input_mode = ::std::option::Option::Some(is.read_int32()?);
                    },
                    40 => {
                        self.input_element = ::std::option::Option::Some(is.read_int32()?);
                    },
                    48 => {
                        self.output_gamepad = ::std::option::Option::Some(is.read_int32()?);
                    },
                    56 => {
                        self.output_keyboard = ::std::option::Option::Some(is.read_int32()?);
                    },
                    64 => {
                        self.output_mouse = ::std::option::Option::Some(is.read_int32()?);
                    },
                    74 => {
                        self.icon_foreground = ::std::option::Option::Some(is.read_string()?);
                    },
                    82 => {
                        self.icon_background = ::std::option::Option::Some(is.read_string()?);
                    },
                    88 => {
                        self.input_toggle = ::std::option::Option::Some(is.read_bool()?);
                    },
                    96 => {
                        self.input_activate_stick_or_trackpad = ::std::option::Option::Some(is.read_int32()?);
                    },
                    104 => {
                        self.activation_type = ::std::option::Option::Some(is.read_int32()?);
                    },
                    112 => {
                        self.long_press_ms = ::std::option::Option::Some(is.read_int32()?);
                    },
                    120 => {
                        self.double_press_ms = ::std::option::Option::Some(is.read_int32()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if let Some(v) = self.name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
            }
            if let Some(v) = self.icon.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
            }
            if let Some(v) = self.input_source {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v);
            }
            if let Some(v) = self.input_mode {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v);
            }
            if let Some(v) = self.input_element {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v);
            }
            if let Some(v) = self.output_gamepad {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(6, v);
            }
            if let Some(v) = self.output_keyboard {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(7, v);
            }
            if let Some(v) = self.output_mouse {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(8, v);
            }
            if let Some(v) = self.icon_foreground.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &v);
            }
            if let Some(v) = self.icon_background.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(10, &v);
            }
            if let Some(v) = self.input_toggle {
                my_size += 1 + 1;
            }
            if let Some(v) = self.input_activate_stick_or_trackpad {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(12, v);
            }
            if let Some(v) = self.activation_type {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(13, v);
            }
            if let Some(v) = self.long_press_ms {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(14, v);
            }
            if let Some(v) = self.double_press_ms {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(15, v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.name.as_ref() {
                os.write_string(1, v)?;
            }
            if let Some(v) = self.icon.as_ref() {
                os.write_string(2, v)?;
            }
            if let Some(v) = self.input_source {
                os.write_int32(3, v)?;
            }
            if let Some(v) = self.input_mode {
                os.write_int32(4, v)?;
            }
            if let Some(v) = self.input_element {
                os.write_int32(5, v)?;
            }
            if let Some(v) = self.output_gamepad {
                os.write_int32(6, v)?;
            }
            if let Some(v) = self.output_keyboard {
                os.write_int32(7, v)?;
            }
            if let Some(v) = self.output_mouse {
                os.write_int32(8, v)?;
            }
            if let Some(v) = self.icon_foreground.as_ref() {
                os.write_string(9, v)?;
            }
            if let Some(v) = self.icon_background.as_ref() {
                os.write_string(10, v)?;
            }
            if let Some(v) = self.input_toggle {
                os.write_bool(11, v)?;
            }
            if let Some(v) = self.input_activate_stick_or_trackpad {
                os.write_int32(12, v)?;
            }
            if let Some(v) = self.activation_type {
                os.write_int32(13, v)?;
            }
            if let Some(v) = self.long_press_ms {
                os.write_int32(14, v)?;
            }
            if let Some(v) = self.double_press_ms {
                os.write_int32(15, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.name = ::std::option::Option::None;
            self.icon = ::std::option::Option::None;
            self.input_source = ::std::option::Option::None;
            self.input_mode = ::std::option::Option::None;
            self.input_element = ::std::option::Option::None;
            self.output_gamepad = ::std::option::Option::None;
            self.output_keyboard = ::std::option::Option::None;
            self.output_mouse = ::std::option::Option::None;
            self.icon_foreground = ::std::option::Option::None;
            self.icon_background = ::std::option::Option::None;
            self.input_toggle = ::std::option::Option::None;
            self.input_activate_stick_or_trackpad = ::std::option::Option::None;
            self.activation_type = ::std::option::Option::None;
            self.long_press_ms = ::std::option::Option::None;
            self.double_press_ms = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Control {
            static instance: Control = Control {
                name: ::std::option::Option::None,
                icon: ::std::option::Option::None,
                input_source: ::std::option::Option::None,
                input_mode: ::std::option::Option::None,
                input_element: ::std::option::Option::None,
                output_gamepad: ::std::option::Option::None,
                output_keyboard: ::std::option::Option::None,
                output_mouse: ::std::option::Option::None,
                icon_foreground: ::std::option::Option::None,
                icon_background: ::std::option::Option::None,
                input_toggle: ::std::option::Option::None,
                input_activate_stick_or_trackpad: ::std::option::Option::None,
                activation_type: ::std::option::Option::None,
                long_press_ms: ::std::option::Option::None,
                double_press_ms: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:CVirtualControllerConfig.ActionSet)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct ActionSet {
        // message fields
        // @@protoc_insertion_point(field:CVirtualControllerConfig.ActionSet.id)
        pub id: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.ActionSet.parent_id)
        pub parent_id: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.ActionSet.name)
        pub name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CVirtualControllerConfig.ActionSet.controls)
        pub controls: ::std::vec::Vec<Control>,
        // special fields
        // @@protoc_insertion_point(special_field:CVirtualControllerConfig.ActionSet.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional int32 id = 1;

        pub fn id(&self) -> i32 {
            self.id.unwrap_or(0)
        }

        pub fn clear_id(&mut self) {
            self.id = ::std::option::Option::None;
        }

        pub fn has_id(&self) -> bool {
            self.id.is_some()
        }

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

        // optional int32 parent_id = 2;

        pub fn parent_id(&self) -> i32 {
            self.parent_id.unwrap_or(0)
        }

        pub fn clear_parent_id(&mut self) {
            self.parent_id = ::std::option::Option::None;
        }

        pub fn has_parent_id(&self) -> bool {
            self.parent_id.is_some()
        }

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

        // optional string name = 3;

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

        pub fn clear_name(&mut self) {
            self.name = ::std::option::Option::None;
        }

        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 = ::std::option::Option::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 = ::std::option::Option::Some(::std::string::String::new());
            }
            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())
        }
    }

    impl ::steam_vent_proto_common::protobuf::Message for ActionSet {
        const NAME: &'static str = "ActionSet";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.id = ::std::option::Option::Some(is.read_int32()?);
                    },
                    16 => {
                        self.parent_id = ::std::option::Option::Some(is.read_int32()?);
                    },
                    26 => {
                        self.name = ::std::option::Option::Some(is.read_string()?);
                    },
                    34 => {
                        self.controls.push(is.read_message()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if let Some(v) = self.id {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
            }
            if let Some(v) = self.parent_id {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
            }
            if let Some(v) = self.name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
            }
            for value in &self.controls {
                let len = value.compute_size();
                my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.id {
                os.write_int32(1, v)?;
            }
            if let Some(v) = self.parent_id {
                os.write_int32(2, v)?;
            }
            if let Some(v) = self.name.as_ref() {
                os.write_string(3, v)?;
            }
            for v in &self.controls {
                ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
            };
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.id = ::std::option::Option::None;
            self.parent_id = ::std::option::Option::None;
            self.name = ::std::option::Option::None;
            self.controls.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static ActionSet {
            static instance: ActionSet = ActionSet {
                id: ::std::option::Option::None,
                parent_id: ::std::option::Option::None,
                name: ::std::option::Option::None,
                controls: ::std::vec::Vec::new(),
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CVirtualControllerLayoutPackage)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVirtualControllerLayoutPackage {
    // message fields
    // @@protoc_insertion_point(field:CVirtualControllerLayoutPackage.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CVirtualControllerLayoutPackage.creator)
    pub creator: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CVirtualControllerLayoutPackage.initial_revision)
    pub initial_revision: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CVirtualControllerLayoutPackage.saved_revision)
    pub saved_revision: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CVirtualControllerLayoutPackage.config)
    pub config: ::steam_vent_proto_common::protobuf::MessageField<CVirtualControllerConfig>,
    // @@protoc_insertion_point(field:CVirtualControllerLayoutPackage.layouts)
    pub layouts: ::steam_vent_proto_common::protobuf::MessageField<CVirtualControllerLayouts>,
    // special fields
    // @@protoc_insertion_point(special_field:CVirtualControllerLayoutPackage.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 appid = 1;

    pub fn appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }

    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

    pub fn has_appid(&self) -> bool {
        self.appid.is_some()
    }

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

    // optional uint64 creator = 2;

    pub fn creator(&self) -> u64 {
        self.creator.unwrap_or(0)
    }

    pub fn clear_creator(&mut self) {
        self.creator = ::std::option::Option::None;
    }

    pub fn has_creator(&self) -> bool {
        self.creator.is_some()
    }

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

    // optional uint32 initial_revision = 3;

    pub fn initial_revision(&self) -> u32 {
        self.initial_revision.unwrap_or(0)
    }

    pub fn clear_initial_revision(&mut self) {
        self.initial_revision = ::std::option::Option::None;
    }

    pub fn has_initial_revision(&self) -> bool {
        self.initial_revision.is_some()
    }

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

    // optional uint32 saved_revision = 4;

    pub fn saved_revision(&self) -> u32 {
        self.saved_revision.unwrap_or(0)
    }

    pub fn clear_saved_revision(&mut self) {
        self.saved_revision = ::std::option::Option::None;
    }

    pub fn has_saved_revision(&self) -> bool {
        self.saved_revision.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CVirtualControllerLayoutPackage {
    const NAME: &'static str = "CVirtualControllerLayoutPackage";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.creator = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.initial_revision = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.saved_revision = ::std::option::Option::Some(is.read_uint32()?);
                },
                42 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.config)?;
                },
                50 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.layouts)?;
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.creator {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.initial_revision {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.saved_revision {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.config.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.layouts.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.creator {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.initial_revision {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.saved_revision {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.config.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        }
        if let Some(v) = self.layouts.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.creator = ::std::option::Option::None;
        self.initial_revision = ::std::option::Option::None;
        self.saved_revision = ::std::option::Option::None;
        self.config.clear();
        self.layouts.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CVirtualControllerLayoutPackage {
        static instance: CVirtualControllerLayoutPackage = CVirtualControllerLayoutPackage {
            appid: ::std::option::Option::None,
            creator: ::std::option::Option::None,
            initial_revision: ::std::option::Option::None,
            saved_revision: ::std::option::Option::None,
            config: ::steam_vent_proto_common::protobuf::MessageField::none(),
            layouts: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CVirtualControllerGlobalConfig)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVirtualControllerGlobalConfig {
    // message fields
    // @@protoc_insertion_point(field:CVirtualControllerGlobalConfig.feedback_enabled)
    pub feedback_enabled: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CVirtualControllerGlobalConfig.gyroscope_enabled)
    pub gyroscope_enabled: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CVirtualControllerGlobalConfig.auto_fade_enabled)
    pub auto_fade_enabled: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CVirtualControllerGlobalConfig.rumble_enabled)
    pub rumble_enabled: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CVirtualControllerGlobalConfig.shake_fade_enabled)
    pub shake_fade_enabled: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CVirtualControllerGlobalConfig.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional bool feedback_enabled = 1;

    pub fn feedback_enabled(&self) -> bool {
        self.feedback_enabled.unwrap_or(false)
    }

    pub fn clear_feedback_enabled(&mut self) {
        self.feedback_enabled = ::std::option::Option::None;
    }

    pub fn has_feedback_enabled(&self) -> bool {
        self.feedback_enabled.is_some()
    }

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

    // optional bool gyroscope_enabled = 2;

    pub fn gyroscope_enabled(&self) -> bool {
        self.gyroscope_enabled.unwrap_or(true)
    }

    pub fn clear_gyroscope_enabled(&mut self) {
        self.gyroscope_enabled = ::std::option::Option::None;
    }

    pub fn has_gyroscope_enabled(&self) -> bool {
        self.gyroscope_enabled.is_some()
    }

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

    // optional bool auto_fade_enabled = 3;

    pub fn auto_fade_enabled(&self) -> bool {
        self.auto_fade_enabled.unwrap_or(true)
    }

    pub fn clear_auto_fade_enabled(&mut self) {
        self.auto_fade_enabled = ::std::option::Option::None;
    }

    pub fn has_auto_fade_enabled(&self) -> bool {
        self.auto_fade_enabled.is_some()
    }

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

    // optional bool rumble_enabled = 4;

    pub fn rumble_enabled(&self) -> bool {
        self.rumble_enabled.unwrap_or(true)
    }

    pub fn clear_rumble_enabled(&mut self) {
        self.rumble_enabled = ::std::option::Option::None;
    }

    pub fn has_rumble_enabled(&self) -> bool {
        self.rumble_enabled.is_some()
    }

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

    // optional bool shake_fade_enabled = 5;

    pub fn shake_fade_enabled(&self) -> bool {
        self.shake_fade_enabled.unwrap_or(false)
    }

    pub fn clear_shake_fade_enabled(&mut self) {
        self.shake_fade_enabled = ::std::option::Option::None;
    }

    pub fn has_shake_fade_enabled(&self) -> bool {
        self.shake_fade_enabled.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CVirtualControllerGlobalConfig {
    const NAME: &'static str = "CVirtualControllerGlobalConfig";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.feedback_enabled = ::std::option::Option::Some(is.read_bool()?);
                },
                16 => {
                    self.gyroscope_enabled = ::std::option::Option::Some(is.read_bool()?);
                },
                24 => {
                    self.auto_fade_enabled = ::std::option::Option::Some(is.read_bool()?);
                },
                32 => {
                    self.rumble_enabled = ::std::option::Option::Some(is.read_bool()?);
                },
                40 => {
                    self.shake_fade_enabled = ::std::option::Option::Some(is.read_bool()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.feedback_enabled {
            my_size += 1 + 1;
        }
        if let Some(v) = self.gyroscope_enabled {
            my_size += 1 + 1;
        }
        if let Some(v) = self.auto_fade_enabled {
            my_size += 1 + 1;
        }
        if let Some(v) = self.rumble_enabled {
            my_size += 1 + 1;
        }
        if let Some(v) = self.shake_fade_enabled {
            my_size += 1 + 1;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.feedback_enabled {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.gyroscope_enabled {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.auto_fade_enabled {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.rumble_enabled {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.shake_fade_enabled {
            os.write_bool(5, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.feedback_enabled = ::std::option::Option::None;
        self.gyroscope_enabled = ::std::option::Option::None;
        self.auto_fade_enabled = ::std::option::Option::None;
        self.rumble_enabled = ::std::option::Option::None;
        self.shake_fade_enabled = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CVirtualControllerGlobalConfig {
        static instance: CVirtualControllerGlobalConfig = CVirtualControllerGlobalConfig {
            feedback_enabled: ::std::option::Option::None,
            gyroscope_enabled: ::std::option::Option::None,
            auto_fade_enabled: ::std::option::Option::None,
            rumble_enabled: ::std::option::Option::None,
            shake_fade_enabled: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:EInputMode)
pub enum EInputMode {
    // @@protoc_insertion_point(enum_value:EInputMode.k_EInputModeUnknown)
    k_EInputModeUnknown = 0,
    // @@protoc_insertion_point(enum_value:EInputMode.k_EInputModeMouse)
    k_EInputModeMouse = 1,
    // @@protoc_insertion_point(enum_value:EInputMode.k_EInputModeController)
    k_EInputModeController = 2,
    // @@protoc_insertion_point(enum_value:EInputMode.k_EInputModeMouseAndController)
    k_EInputModeMouseAndController = 3,
}

impl ::steam_vent_proto_common::protobuf::Enum for EInputMode {
    const NAME: &'static str = "EInputMode";

    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<EInputMode> {
        match value {
            0 => ::std::option::Option::Some(EInputMode::k_EInputModeUnknown),
            1 => ::std::option::Option::Some(EInputMode::k_EInputModeMouse),
            2 => ::std::option::Option::Some(EInputMode::k_EInputModeController),
            3 => ::std::option::Option::Some(EInputMode::k_EInputModeMouseAndController),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<EInputMode> {
        match str {
            "k_EInputModeUnknown" => ::std::option::Option::Some(EInputMode::k_EInputModeUnknown),
            "k_EInputModeMouse" => ::std::option::Option::Some(EInputMode::k_EInputModeMouse),
            "k_EInputModeController" => ::std::option::Option::Some(EInputMode::k_EInputModeController),
            "k_EInputModeMouseAndController" => ::std::option::Option::Some(EInputMode::k_EInputModeMouseAndController),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [EInputMode] = &[
        EInputMode::k_EInputModeUnknown,
        EInputMode::k_EInputModeMouse,
        EInputMode::k_EInputModeController,
        EInputMode::k_EInputModeMouseAndController,
    ];
}

impl ::std::default::Default for EInputMode {
    fn default() -> Self {
        EInputMode::k_EInputModeUnknown
    }
}


#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:EMouseMode)
pub enum EMouseMode {
    // @@protoc_insertion_point(enum_value:EMouseMode.k_EMouseModeUnknown)
    k_EMouseModeUnknown = 0,
    // @@protoc_insertion_point(enum_value:EMouseMode.k_EMouseModeRelativeCursor)
    k_EMouseModeRelativeCursor = 1,
    // @@protoc_insertion_point(enum_value:EMouseMode.k_EMouseModeAbsoluteCursor)
    k_EMouseModeAbsoluteCursor = 2,
    // @@protoc_insertion_point(enum_value:EMouseMode.k_EMouseModeTouch)
    k_EMouseModeTouch = 3,
    // @@protoc_insertion_point(enum_value:EMouseMode.k_EMouseModeRelative)
    k_EMouseModeRelative = 4,
}

impl ::steam_vent_proto_common::protobuf::Enum for EMouseMode {
    const NAME: &'static str = "EMouseMode";

    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<EMouseMode> {
        match value {
            0 => ::std::option::Option::Some(EMouseMode::k_EMouseModeUnknown),
            1 => ::std::option::Option::Some(EMouseMode::k_EMouseModeRelativeCursor),
            2 => ::std::option::Option::Some(EMouseMode::k_EMouseModeAbsoluteCursor),
            3 => ::std::option::Option::Some(EMouseMode::k_EMouseModeTouch),
            4 => ::std::option::Option::Some(EMouseMode::k_EMouseModeRelative),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<EMouseMode> {
        match str {
            "k_EMouseModeUnknown" => ::std::option::Option::Some(EMouseMode::k_EMouseModeUnknown),
            "k_EMouseModeRelativeCursor" => ::std::option::Option::Some(EMouseMode::k_EMouseModeRelativeCursor),
            "k_EMouseModeAbsoluteCursor" => ::std::option::Option::Some(EMouseMode::k_EMouseModeAbsoluteCursor),
            "k_EMouseModeTouch" => ::std::option::Option::Some(EMouseMode::k_EMouseModeTouch),
            "k_EMouseModeRelative" => ::std::option::Option::Some(EMouseMode::k_EMouseModeRelative),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [EMouseMode] = &[
        EMouseMode::k_EMouseModeUnknown,
        EMouseMode::k_EMouseModeRelativeCursor,
        EMouseMode::k_EMouseModeAbsoluteCursor,
        EMouseMode::k_EMouseModeTouch,
        EMouseMode::k_EMouseModeRelative,
    ];
}

impl ::std::default::Default for EMouseMode {
    fn default() -> Self {
        EMouseMode::k_EMouseModeUnknown
    }
}


#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:EControllerElementType)
pub enum EControllerElementType {
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeNone)
    k_EControllerElementTypeNone = -1,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeThumb)
    k_EControllerElementTypeThumb = 0,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonSteam)
    k_EControllerElementTypeButtonSteam = 1,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeJoystickLeft)
    k_EControllerElementTypeJoystickLeft = 2,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonJoystickLeft)
    k_EControllerElementTypeButtonJoystickLeft = 3,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeJoystickRight)
    k_EControllerElementTypeJoystickRight = 4,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonJoystickRight)
    k_EControllerElementTypeButtonJoystickRight = 5,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeDPad)
    k_EControllerElementTypeDPad = 6,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonA)
    k_EControllerElementTypeButtonA = 7,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonB)
    k_EControllerElementTypeButtonB = 8,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonX)
    k_EControllerElementTypeButtonX = 9,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonY)
    k_EControllerElementTypeButtonY = 10,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonSelect)
    k_EControllerElementTypeButtonSelect = 11,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonStart)
    k_EControllerElementTypeButtonStart = 12,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonTriggerLeft)
    k_EControllerElementTypeButtonTriggerLeft = 13,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonTriggerRight)
    k_EControllerElementTypeButtonTriggerRight = 14,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonBumperLeft)
    k_EControllerElementTypeButtonBumperLeft = 15,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonBumperRight)
    k_EControllerElementTypeButtonBumperRight = 16,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonMacro0)
    k_EControllerElementTypeButtonMacro0 = 17,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonMacro1)
    k_EControllerElementTypeButtonMacro1 = 18,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonMacro2)
    k_EControllerElementTypeButtonMacro2 = 19,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonMacro3)
    k_EControllerElementTypeButtonMacro3 = 20,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonMacro4)
    k_EControllerElementTypeButtonMacro4 = 21,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonMacro5)
    k_EControllerElementTypeButtonMacro5 = 22,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonMacro6)
    k_EControllerElementTypeButtonMacro6 = 23,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonMacro7)
    k_EControllerElementTypeButtonMacro7 = 24,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeTrackpadCenter)
    k_EControllerElementTypeTrackpadCenter = 25,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeTrackpadLeft)
    k_EControllerElementTypeTrackpadLeft = 26,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeTrackpadRight)
    k_EControllerElementTypeTrackpadRight = 27,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeKeyboard)
    k_EControllerElementTypeKeyboard = 28,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeMagnifyingGlass)
    k_EControllerElementTypeMagnifyingGlass = 29,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonMacro1Finger)
    k_EControllerElementTypeButtonMacro1Finger = 30,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeButtonMacro2Finger)
    k_EControllerElementTypeButtonMacro2Finger = 31,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeRecordInput)
    k_EControllerElementTypeRecordInput = 32,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypePlaybackInput)
    k_EControllerElementTypePlaybackInput = 33,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypePaste)
    k_EControllerElementTypePaste = 34,
    // @@protoc_insertion_point(enum_value:EControllerElementType.k_EControllerElementTypeMax)
    k_EControllerElementTypeMax = 35,
}

impl ::steam_vent_proto_common::protobuf::Enum for EControllerElementType {
    const NAME: &'static str = "EControllerElementType";

    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<EControllerElementType> {
        match value {
            -1 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeNone),
            0 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeThumb),
            1 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonSteam),
            2 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeJoystickLeft),
            3 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonJoystickLeft),
            4 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeJoystickRight),
            5 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonJoystickRight),
            6 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeDPad),
            7 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonA),
            8 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonB),
            9 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonX),
            10 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonY),
            11 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonSelect),
            12 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonStart),
            13 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonTriggerLeft),
            14 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonTriggerRight),
            15 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonBumperLeft),
            16 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonBumperRight),
            17 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro0),
            18 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro1),
            19 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro2),
            20 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro3),
            21 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro4),
            22 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro5),
            23 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro6),
            24 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro7),
            25 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeTrackpadCenter),
            26 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeTrackpadLeft),
            27 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeTrackpadRight),
            28 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeKeyboard),
            29 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeMagnifyingGlass),
            30 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro1Finger),
            31 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro2Finger),
            32 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeRecordInput),
            33 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypePlaybackInput),
            34 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypePaste),
            35 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeMax),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<EControllerElementType> {
        match str {
            "k_EControllerElementTypeNone" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeNone),
            "k_EControllerElementTypeThumb" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeThumb),
            "k_EControllerElementTypeButtonSteam" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonSteam),
            "k_EControllerElementTypeJoystickLeft" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeJoystickLeft),
            "k_EControllerElementTypeButtonJoystickLeft" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonJoystickLeft),
            "k_EControllerElementTypeJoystickRight" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeJoystickRight),
            "k_EControllerElementTypeButtonJoystickRight" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonJoystickRight),
            "k_EControllerElementTypeDPad" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeDPad),
            "k_EControllerElementTypeButtonA" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonA),
            "k_EControllerElementTypeButtonB" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonB),
            "k_EControllerElementTypeButtonX" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonX),
            "k_EControllerElementTypeButtonY" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonY),
            "k_EControllerElementTypeButtonSelect" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonSelect),
            "k_EControllerElementTypeButtonStart" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonStart),
            "k_EControllerElementTypeButtonTriggerLeft" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonTriggerLeft),
            "k_EControllerElementTypeButtonTriggerRight" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonTriggerRight),
            "k_EControllerElementTypeButtonBumperLeft" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonBumperLeft),
            "k_EControllerElementTypeButtonBumperRight" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonBumperRight),
            "k_EControllerElementTypeButtonMacro0" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro0),
            "k_EControllerElementTypeButtonMacro1" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro1),
            "k_EControllerElementTypeButtonMacro2" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro2),
            "k_EControllerElementTypeButtonMacro3" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro3),
            "k_EControllerElementTypeButtonMacro4" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro4),
            "k_EControllerElementTypeButtonMacro5" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro5),
            "k_EControllerElementTypeButtonMacro6" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro6),
            "k_EControllerElementTypeButtonMacro7" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro7),
            "k_EControllerElementTypeTrackpadCenter" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeTrackpadCenter),
            "k_EControllerElementTypeTrackpadLeft" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeTrackpadLeft),
            "k_EControllerElementTypeTrackpadRight" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeTrackpadRight),
            "k_EControllerElementTypeKeyboard" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeKeyboard),
            "k_EControllerElementTypeMagnifyingGlass" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeMagnifyingGlass),
            "k_EControllerElementTypeButtonMacro1Finger" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro1Finger),
            "k_EControllerElementTypeButtonMacro2Finger" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro2Finger),
            "k_EControllerElementTypeRecordInput" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeRecordInput),
            "k_EControllerElementTypePlaybackInput" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypePlaybackInput),
            "k_EControllerElementTypePaste" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypePaste),
            "k_EControllerElementTypeMax" => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeMax),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [EControllerElementType] = &[
        EControllerElementType::k_EControllerElementTypeNone,
        EControllerElementType::k_EControllerElementTypeThumb,
        EControllerElementType::k_EControllerElementTypeButtonSteam,
        EControllerElementType::k_EControllerElementTypeJoystickLeft,
        EControllerElementType::k_EControllerElementTypeButtonJoystickLeft,
        EControllerElementType::k_EControllerElementTypeJoystickRight,
        EControllerElementType::k_EControllerElementTypeButtonJoystickRight,
        EControllerElementType::k_EControllerElementTypeDPad,
        EControllerElementType::k_EControllerElementTypeButtonA,
        EControllerElementType::k_EControllerElementTypeButtonB,
        EControllerElementType::k_EControllerElementTypeButtonX,
        EControllerElementType::k_EControllerElementTypeButtonY,
        EControllerElementType::k_EControllerElementTypeButtonSelect,
        EControllerElementType::k_EControllerElementTypeButtonStart,
        EControllerElementType::k_EControllerElementTypeButtonTriggerLeft,
        EControllerElementType::k_EControllerElementTypeButtonTriggerRight,
        EControllerElementType::k_EControllerElementTypeButtonBumperLeft,
        EControllerElementType::k_EControllerElementTypeButtonBumperRight,
        EControllerElementType::k_EControllerElementTypeButtonMacro0,
        EControllerElementType::k_EControllerElementTypeButtonMacro1,
        EControllerElementType::k_EControllerElementTypeButtonMacro2,
        EControllerElementType::k_EControllerElementTypeButtonMacro3,
        EControllerElementType::k_EControllerElementTypeButtonMacro4,
        EControllerElementType::k_EControllerElementTypeButtonMacro5,
        EControllerElementType::k_EControllerElementTypeButtonMacro6,
        EControllerElementType::k_EControllerElementTypeButtonMacro7,
        EControllerElementType::k_EControllerElementTypeTrackpadCenter,
        EControllerElementType::k_EControllerElementTypeTrackpadLeft,
        EControllerElementType::k_EControllerElementTypeTrackpadRight,
        EControllerElementType::k_EControllerElementTypeKeyboard,
        EControllerElementType::k_EControllerElementTypeMagnifyingGlass,
        EControllerElementType::k_EControllerElementTypeButtonMacro1Finger,
        EControllerElementType::k_EControllerElementTypeButtonMacro2Finger,
        EControllerElementType::k_EControllerElementTypeRecordInput,
        EControllerElementType::k_EControllerElementTypePlaybackInput,
        EControllerElementType::k_EControllerElementTypePaste,
        EControllerElementType::k_EControllerElementTypeMax,
    ];
}

// Note, `Default` is implemented although default value is not 0
impl ::std::default::Default for EControllerElementType {
    fn default() -> Self {
        EControllerElementType::k_EControllerElementTypeNone
    }
}



const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;

impl ::steam_vent_proto_common::RpcMessage for CVirtualControllerElement {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CVirtualControllerColor {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CVirtualControllerLayout {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CVirtualControllerLayouts {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CVirtualControllerConfig {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CVirtualControllerLayoutPackage {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CVirtualControllerGlobalConfig {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
