// 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 `webuimessages_steamos.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:CMsgFactoryResetState)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgFactoryResetState {
    // message fields
    // @@protoc_insertion_point(field:CMsgFactoryResetState.is_running)
    pub is_running: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgFactoryResetState.progress)
    pub progress: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgFactoryResetState.is_restart_pending)
    pub is_restart_pending: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgFactoryResetState.rtime_estimated_completion)
    pub rtime_estimated_completion: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgFactoryResetState.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional bool is_running = 1;

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

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

    pub fn has_is_running(&self) -> bool {
        self.is_running.is_some()
    }

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

    // optional int32 progress = 2;

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

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

    pub fn has_progress(&self) -> bool {
        self.progress.is_some()
    }

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

    // optional bool is_restart_pending = 3;

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

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

    pub fn has_is_restart_pending(&self) -> bool {
        self.is_restart_pending.is_some()
    }

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

    // optional fixed32 rtime_estimated_completion = 4;

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

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

    pub fn has_rtime_estimated_completion(&self) -> bool {
        self.rtime_estimated_completion.is_some()
    }

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

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

    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.is_running = ::std::option::Option::Some(is.read_bool()?);
                },
                16 => {
                    self.progress = ::std::option::Option::Some(is.read_int32()?);
                },
                24 => {
                    self.is_restart_pending = ::std::option::Option::Some(is.read_bool()?);
                },
                37 => {
                    self.rtime_estimated_completion = ::std::option::Option::Some(is.read_fixed32()?);
                },
                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.is_running {
            my_size += 1 + 1;
        }
        if let Some(v) = self.progress {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
        }
        if let Some(v) = self.is_restart_pending {
            my_size += 1 + 1;
        }
        if let Some(v) = self.rtime_estimated_completion {
            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.is_running {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.progress {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.is_restart_pending {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.rtime_estimated_completion {
            os.write_fixed32(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() -> CMsgFactoryResetState {
        CMsgFactoryResetState::new()
    }

    fn clear(&mut self) {
        self.is_running = ::std::option::Option::None;
        self.progress = ::std::option::Option::None;
        self.is_restart_pending = ::std::option::Option::None;
        self.rtime_estimated_completion = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgFactoryResetState {
        static instance: CMsgFactoryResetState = CMsgFactoryResetState {
            is_running: ::std::option::Option::None,
            progress: ::std::option::Option::None,
            is_restart_pending: ::std::option::Option::None,
            rtime_estimated_completion: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSManagerState)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSManagerState {
    // message fields
    // @@protoc_insertion_point(field:CSteamOSManagerState.is_service_available)
    pub is_service_available: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.os_version)
    pub os_version: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.is_mandatory_update_available)
    pub is_mandatory_update_available: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.startup_movie_variant)
    pub startup_movie_variant: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::enums::EStartupMovieVariant>>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.is_status_led_control_available)
    pub is_status_led_control_available: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.factory_reset_state)
    pub factory_reset_state: ::steam_vent_proto_common::protobuf::MessageField<CMsgFactoryResetState>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.is_tdp_limit_available)
    pub is_tdp_limit_available: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.tdp_limit_min)
    pub tdp_limit_min: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.tdp_limit_max)
    pub tdp_limit_max: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.is_cec_available)
    pub is_cec_available: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.is_wifi_debug_supported)
    pub is_wifi_debug_supported: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.is_wifi_debug_force_disabled)
    pub is_wifi_debug_force_disabled: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.is_wifi_force_wpa_supplicant_supported)
    pub is_wifi_force_wpa_supplicant_supported: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.is_manual_gpu_clock_available)
    pub is_manual_gpu_clock_available: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.manual_gpu_clock_min)
    pub manual_gpu_clock_min: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.manual_gpu_clock_max)
    pub manual_gpu_clock_max: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.platform_performance_profiles_available)
    pub platform_performance_profiles_available: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.platform_performance_profile_default)
    pub platform_performance_profile_default: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.is_charge_limit_available)
    pub is_charge_limit_available: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.charge_limit_min)
    pub charge_limit_min: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.charge_limit_max)
    pub charge_limit_max: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.charge_limit_default)
    pub charge_limit_default: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.is_screen_reader_supported)
    pub is_screen_reader_supported: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.screen_reader_locales_available)
    pub screen_reader_locales_available: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.screen_reader_locale_default)
    pub screen_reader_locale_default: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.is_system_tracing_available)
    pub is_system_tracing_available: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSManagerState.is_vrs_available)
    pub is_vrs_available: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSManagerState.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional bool is_service_available = 1;

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

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

    pub fn has_is_service_available(&self) -> bool {
        self.is_service_available.is_some()
    }

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

    // optional string os_version = 2;

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

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

    pub fn has_os_version(&self) -> bool {
        self.os_version.is_some()
    }

    // Param is passed by value, moved
    pub fn set_os_version(&mut self, v: ::std::string::String) {
        self.os_version = ::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_os_version(&mut self) -> &mut ::std::string::String {
        if self.os_version.is_none() {
            self.os_version = ::std::option::Option::Some(::std::string::String::new());
        }
        self.os_version.as_mut().unwrap()
    }

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

    // optional bool is_mandatory_update_available = 3;

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

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

    pub fn has_is_mandatory_update_available(&self) -> bool {
        self.is_mandatory_update_available.is_some()
    }

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

    // optional .EStartupMovieVariant startup_movie_variant = 4;

    pub fn startup_movie_variant(&self) -> super::enums::EStartupMovieVariant {
        match self.startup_movie_variant {
            Some(e) => e.enum_value_or(super::enums::EStartupMovieVariant::k_EStartupMovieVariant_Invalid),
            None => super::enums::EStartupMovieVariant::k_EStartupMovieVariant_Invalid,
        }
    }

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

    pub fn has_startup_movie_variant(&self) -> bool {
        self.startup_movie_variant.is_some()
    }

    // Param is passed by value, moved
    pub fn set_startup_movie_variant(&mut self, v: super::enums::EStartupMovieVariant) {
        self.startup_movie_variant = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional bool is_status_led_control_available = 5;

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

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

    pub fn has_is_status_led_control_available(&self) -> bool {
        self.is_status_led_control_available.is_some()
    }

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

    // optional bool is_tdp_limit_available = 7;

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

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

    pub fn has_is_tdp_limit_available(&self) -> bool {
        self.is_tdp_limit_available.is_some()
    }

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

    // optional int32 tdp_limit_min = 8;

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

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

    pub fn has_tdp_limit_min(&self) -> bool {
        self.tdp_limit_min.is_some()
    }

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

    // optional int32 tdp_limit_max = 9;

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

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

    pub fn has_tdp_limit_max(&self) -> bool {
        self.tdp_limit_max.is_some()
    }

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

    // optional bool is_cec_available = 10;

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

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

    pub fn has_is_cec_available(&self) -> bool {
        self.is_cec_available.is_some()
    }

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

    // optional bool is_wifi_debug_supported = 11;

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

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

    pub fn has_is_wifi_debug_supported(&self) -> bool {
        self.is_wifi_debug_supported.is_some()
    }

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

    // optional bool is_wifi_debug_force_disabled = 12;

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

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

    pub fn has_is_wifi_debug_force_disabled(&self) -> bool {
        self.is_wifi_debug_force_disabled.is_some()
    }

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

    // optional bool is_wifi_force_wpa_supplicant_supported = 13;

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

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

    pub fn has_is_wifi_force_wpa_supplicant_supported(&self) -> bool {
        self.is_wifi_force_wpa_supplicant_supported.is_some()
    }

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

    // optional bool is_manual_gpu_clock_available = 14;

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

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

    pub fn has_is_manual_gpu_clock_available(&self) -> bool {
        self.is_manual_gpu_clock_available.is_some()
    }

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

    // optional int32 manual_gpu_clock_min = 15;

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

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

    pub fn has_manual_gpu_clock_min(&self) -> bool {
        self.manual_gpu_clock_min.is_some()
    }

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

    // optional int32 manual_gpu_clock_max = 16;

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

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

    pub fn has_manual_gpu_clock_max(&self) -> bool {
        self.manual_gpu_clock_max.is_some()
    }

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

    // optional string platform_performance_profile_default = 18;

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

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

    pub fn has_platform_performance_profile_default(&self) -> bool {
        self.platform_performance_profile_default.is_some()
    }

    // Param is passed by value, moved
    pub fn set_platform_performance_profile_default(&mut self, v: ::std::string::String) {
        self.platform_performance_profile_default = ::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_platform_performance_profile_default(&mut self) -> &mut ::std::string::String {
        if self.platform_performance_profile_default.is_none() {
            self.platform_performance_profile_default = ::std::option::Option::Some(::std::string::String::new());
        }
        self.platform_performance_profile_default.as_mut().unwrap()
    }

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

    // optional bool is_charge_limit_available = 20;

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

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

    pub fn has_is_charge_limit_available(&self) -> bool {
        self.is_charge_limit_available.is_some()
    }

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

    // optional int32 charge_limit_min = 21;

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

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

    pub fn has_charge_limit_min(&self) -> bool {
        self.charge_limit_min.is_some()
    }

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

    // optional int32 charge_limit_max = 22;

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

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

    pub fn has_charge_limit_max(&self) -> bool {
        self.charge_limit_max.is_some()
    }

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

    // optional int32 charge_limit_default = 23;

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

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

    pub fn has_charge_limit_default(&self) -> bool {
        self.charge_limit_default.is_some()
    }

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

    // optional bool is_screen_reader_supported = 24;

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

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

    pub fn has_is_screen_reader_supported(&self) -> bool {
        self.is_screen_reader_supported.is_some()
    }

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

    // optional string screen_reader_locale_default = 26;

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

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

    pub fn has_screen_reader_locale_default(&self) -> bool {
        self.screen_reader_locale_default.is_some()
    }

    // Param is passed by value, moved
    pub fn set_screen_reader_locale_default(&mut self, v: ::std::string::String) {
        self.screen_reader_locale_default = ::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_screen_reader_locale_default(&mut self) -> &mut ::std::string::String {
        if self.screen_reader_locale_default.is_none() {
            self.screen_reader_locale_default = ::std::option::Option::Some(::std::string::String::new());
        }
        self.screen_reader_locale_default.as_mut().unwrap()
    }

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

    // optional bool is_system_tracing_available = 27;

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

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

    pub fn has_is_system_tracing_available(&self) -> bool {
        self.is_system_tracing_available.is_some()
    }

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

    // optional bool is_vrs_available = 28;

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

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

    pub fn has_is_vrs_available(&self) -> bool {
        self.is_vrs_available.is_some()
    }

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

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

    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.is_service_available = ::std::option::Option::Some(is.read_bool()?);
                },
                18 => {
                    self.os_version = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.is_mandatory_update_available = ::std::option::Option::Some(is.read_bool()?);
                },
                32 => {
                    self.startup_movie_variant = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                40 => {
                    self.is_status_led_control_available = ::std::option::Option::Some(is.read_bool()?);
                },
                50 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.factory_reset_state)?;
                },
                56 => {
                    self.is_tdp_limit_available = ::std::option::Option::Some(is.read_bool()?);
                },
                64 => {
                    self.tdp_limit_min = ::std::option::Option::Some(is.read_int32()?);
                },
                72 => {
                    self.tdp_limit_max = ::std::option::Option::Some(is.read_int32()?);
                },
                80 => {
                    self.is_cec_available = ::std::option::Option::Some(is.read_bool()?);
                },
                88 => {
                    self.is_wifi_debug_supported = ::std::option::Option::Some(is.read_bool()?);
                },
                96 => {
                    self.is_wifi_debug_force_disabled = ::std::option::Option::Some(is.read_bool()?);
                },
                104 => {
                    self.is_wifi_force_wpa_supplicant_supported = ::std::option::Option::Some(is.read_bool()?);
                },
                112 => {
                    self.is_manual_gpu_clock_available = ::std::option::Option::Some(is.read_bool()?);
                },
                120 => {
                    self.manual_gpu_clock_min = ::std::option::Option::Some(is.read_int32()?);
                },
                128 => {
                    self.manual_gpu_clock_max = ::std::option::Option::Some(is.read_int32()?);
                },
                138 => {
                    self.platform_performance_profiles_available.push(is.read_string()?);
                },
                146 => {
                    self.platform_performance_profile_default = ::std::option::Option::Some(is.read_string()?);
                },
                160 => {
                    self.is_charge_limit_available = ::std::option::Option::Some(is.read_bool()?);
                },
                168 => {
                    self.charge_limit_min = ::std::option::Option::Some(is.read_int32()?);
                },
                176 => {
                    self.charge_limit_max = ::std::option::Option::Some(is.read_int32()?);
                },
                184 => {
                    self.charge_limit_default = ::std::option::Option::Some(is.read_int32()?);
                },
                192 => {
                    self.is_screen_reader_supported = ::std::option::Option::Some(is.read_bool()?);
                },
                202 => {
                    self.screen_reader_locales_available.push(is.read_string()?);
                },
                210 => {
                    self.screen_reader_locale_default = ::std::option::Option::Some(is.read_string()?);
                },
                216 => {
                    self.is_system_tracing_available = ::std::option::Option::Some(is.read_bool()?);
                },
                224 => {
                    self.is_vrs_available = ::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.is_service_available {
            my_size += 1 + 1;
        }
        if let Some(v) = self.os_version.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.is_mandatory_update_available {
            my_size += 1 + 1;
        }
        if let Some(v) = self.startup_movie_variant {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v.value());
        }
        if let Some(v) = self.is_status_led_control_available {
            my_size += 1 + 1;
        }
        if let Some(v) = self.factory_reset_state.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.is_tdp_limit_available {
            my_size += 1 + 1;
        }
        if let Some(v) = self.tdp_limit_min {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(8, v);
        }
        if let Some(v) = self.tdp_limit_max {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(9, v);
        }
        if let Some(v) = self.is_cec_available {
            my_size += 1 + 1;
        }
        if let Some(v) = self.is_wifi_debug_supported {
            my_size += 1 + 1;
        }
        if let Some(v) = self.is_wifi_debug_force_disabled {
            my_size += 1 + 1;
        }
        if let Some(v) = self.is_wifi_force_wpa_supplicant_supported {
            my_size += 1 + 1;
        }
        if let Some(v) = self.is_manual_gpu_clock_available {
            my_size += 1 + 1;
        }
        if let Some(v) = self.manual_gpu_clock_min {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(15, v);
        }
        if let Some(v) = self.manual_gpu_clock_max {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(16, v);
        }
        for value in &self.platform_performance_profiles_available {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(17, &value);
        };
        if let Some(v) = self.platform_performance_profile_default.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(18, &v);
        }
        if let Some(v) = self.is_charge_limit_available {
            my_size += 2 + 1;
        }
        if let Some(v) = self.charge_limit_min {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(21, v);
        }
        if let Some(v) = self.charge_limit_max {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(22, v);
        }
        if let Some(v) = self.charge_limit_default {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(23, v);
        }
        if let Some(v) = self.is_screen_reader_supported {
            my_size += 2 + 1;
        }
        for value in &self.screen_reader_locales_available {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(25, &value);
        };
        if let Some(v) = self.screen_reader_locale_default.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(26, &v);
        }
        if let Some(v) = self.is_system_tracing_available {
            my_size += 2 + 1;
        }
        if let Some(v) = self.is_vrs_available {
            my_size += 2 + 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.is_service_available {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.os_version.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.is_mandatory_update_available {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.startup_movie_variant {
            os.write_enum(4, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.is_status_led_control_available {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.factory_reset_state.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        }
        if let Some(v) = self.is_tdp_limit_available {
            os.write_bool(7, v)?;
        }
        if let Some(v) = self.tdp_limit_min {
            os.write_int32(8, v)?;
        }
        if let Some(v) = self.tdp_limit_max {
            os.write_int32(9, v)?;
        }
        if let Some(v) = self.is_cec_available {
            os.write_bool(10, v)?;
        }
        if let Some(v) = self.is_wifi_debug_supported {
            os.write_bool(11, v)?;
        }
        if let Some(v) = self.is_wifi_debug_force_disabled {
            os.write_bool(12, v)?;
        }
        if let Some(v) = self.is_wifi_force_wpa_supplicant_supported {
            os.write_bool(13, v)?;
        }
        if let Some(v) = self.is_manual_gpu_clock_available {
            os.write_bool(14, v)?;
        }
        if let Some(v) = self.manual_gpu_clock_min {
            os.write_int32(15, v)?;
        }
        if let Some(v) = self.manual_gpu_clock_max {
            os.write_int32(16, v)?;
        }
        for v in &self.platform_performance_profiles_available {
            os.write_string(17, &v)?;
        };
        if let Some(v) = self.platform_performance_profile_default.as_ref() {
            os.write_string(18, v)?;
        }
        if let Some(v) = self.is_charge_limit_available {
            os.write_bool(20, v)?;
        }
        if let Some(v) = self.charge_limit_min {
            os.write_int32(21, v)?;
        }
        if let Some(v) = self.charge_limit_max {
            os.write_int32(22, v)?;
        }
        if let Some(v) = self.charge_limit_default {
            os.write_int32(23, v)?;
        }
        if let Some(v) = self.is_screen_reader_supported {
            os.write_bool(24, v)?;
        }
        for v in &self.screen_reader_locales_available {
            os.write_string(25, &v)?;
        };
        if let Some(v) = self.screen_reader_locale_default.as_ref() {
            os.write_string(26, v)?;
        }
        if let Some(v) = self.is_system_tracing_available {
            os.write_bool(27, v)?;
        }
        if let Some(v) = self.is_vrs_available {
            os.write_bool(28, 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() -> CSteamOSManagerState {
        CSteamOSManagerState::new()
    }

    fn clear(&mut self) {
        self.is_service_available = ::std::option::Option::None;
        self.os_version = ::std::option::Option::None;
        self.is_mandatory_update_available = ::std::option::Option::None;
        self.startup_movie_variant = ::std::option::Option::None;
        self.is_status_led_control_available = ::std::option::Option::None;
        self.factory_reset_state.clear();
        self.is_tdp_limit_available = ::std::option::Option::None;
        self.tdp_limit_min = ::std::option::Option::None;
        self.tdp_limit_max = ::std::option::Option::None;
        self.is_cec_available = ::std::option::Option::None;
        self.is_wifi_debug_supported = ::std::option::Option::None;
        self.is_wifi_debug_force_disabled = ::std::option::Option::None;
        self.is_wifi_force_wpa_supplicant_supported = ::std::option::Option::None;
        self.is_manual_gpu_clock_available = ::std::option::Option::None;
        self.manual_gpu_clock_min = ::std::option::Option::None;
        self.manual_gpu_clock_max = ::std::option::Option::None;
        self.platform_performance_profiles_available.clear();
        self.platform_performance_profile_default = ::std::option::Option::None;
        self.is_charge_limit_available = ::std::option::Option::None;
        self.charge_limit_min = ::std::option::Option::None;
        self.charge_limit_max = ::std::option::Option::None;
        self.charge_limit_default = ::std::option::Option::None;
        self.is_screen_reader_supported = ::std::option::Option::None;
        self.screen_reader_locales_available.clear();
        self.screen_reader_locale_default = ::std::option::Option::None;
        self.is_system_tracing_available = ::std::option::Option::None;
        self.is_vrs_available = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSManagerState {
        static instance: CSteamOSManagerState = CSteamOSManagerState {
            is_service_available: ::std::option::Option::None,
            os_version: ::std::option::Option::None,
            is_mandatory_update_available: ::std::option::Option::None,
            startup_movie_variant: ::std::option::Option::None,
            is_status_led_control_available: ::std::option::Option::None,
            factory_reset_state: ::steam_vent_proto_common::protobuf::MessageField::none(),
            is_tdp_limit_available: ::std::option::Option::None,
            tdp_limit_min: ::std::option::Option::None,
            tdp_limit_max: ::std::option::Option::None,
            is_cec_available: ::std::option::Option::None,
            is_wifi_debug_supported: ::std::option::Option::None,
            is_wifi_debug_force_disabled: ::std::option::Option::None,
            is_wifi_force_wpa_supplicant_supported: ::std::option::Option::None,
            is_manual_gpu_clock_available: ::std::option::Option::None,
            manual_gpu_clock_min: ::std::option::Option::None,
            manual_gpu_clock_max: ::std::option::Option::None,
            platform_performance_profiles_available: ::std::vec::Vec::new(),
            platform_performance_profile_default: ::std::option::Option::None,
            is_charge_limit_available: ::std::option::Option::None,
            charge_limit_min: ::std::option::Option::None,
            charge_limit_max: ::std::option::Option::None,
            charge_limit_default: ::std::option::Option::None,
            is_screen_reader_supported: ::std::option::Option::None,
            screen_reader_locales_available: ::std::vec::Vec::new(),
            screen_reader_locale_default: ::std::option::Option::None,
            is_system_tracing_available: ::std::option::Option::None,
            is_vrs_available: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSManager_GetState_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSManager_GetState_Request {
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSManager_GetState_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

    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 {
                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;
        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<()> {
        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() -> CSteamOSManager_GetState_Request {
        CSteamOSManager_GetState_Request::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSManager_GetState_Request {
        static instance: CSteamOSManager_GetState_Request = CSteamOSManager_GetState_Request {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSManager_GetState_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSManager_GetState_Response {
    // message fields
    // @@protoc_insertion_point(field:CSteamOSManager_GetState_Response.state)
    pub state: ::steam_vent_proto_common::protobuf::MessageField<CSteamOSManagerState>,
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSManager_GetState_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

    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 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.state)?;
                },
                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.state.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.state.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, 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() -> CSteamOSManager_GetState_Response {
        CSteamOSManager_GetState_Response::new()
    }

    fn clear(&mut self) {
        self.state.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSManager_GetState_Response {
        static instance: CSteamOSManager_GetState_Response = CSteamOSManager_GetState_Response {
            state: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSManager_StateChanged_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSManager_StateChanged_Notification {
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSManager_StateChanged_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

    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 {
                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;
        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<()> {
        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() -> CSteamOSManager_StateChanged_Notification {
        CSteamOSManager_StateChanged_Notification::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSManager_StateChanged_Notification {
        static instance: CSteamOSManager_StateChanged_Notification = CSteamOSManager_StateChanged_Notification {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSManager_IsTelemetryHelperAvailable_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSManager_IsTelemetryHelperAvailable_Request {
    // message fields
    // @@protoc_insertion_point(field:CSteamOSManager_IsTelemetryHelperAvailable_Request.etype)
    pub etype: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::enums::ESLSHelper>>,
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSManager_IsTelemetryHelperAvailable_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional .ESLSHelper etype = 1;

    pub fn etype(&self) -> super::enums::ESLSHelper {
        match self.etype {
            Some(e) => e.enum_value_or(super::enums::ESLSHelper::k_ESLSHelper_Invalid),
            None => super::enums::ESLSHelper::k_ESLSHelper_Invalid,
        }
    }

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

    pub fn has_etype(&self) -> bool {
        self.etype.is_some()
    }

    // Param is passed by value, moved
    pub fn set_etype(&mut self, v: super::enums::ESLSHelper) {
        self.etype = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }
}

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

    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.etype = ::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.etype {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, 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.etype {
            os.write_enum(1, ::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() -> CSteamOSManager_IsTelemetryHelperAvailable_Request {
        CSteamOSManager_IsTelemetryHelperAvailable_Request::new()
    }

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

    fn default_instance() -> &'static CSteamOSManager_IsTelemetryHelperAvailable_Request {
        static instance: CSteamOSManager_IsTelemetryHelperAvailable_Request = CSteamOSManager_IsTelemetryHelperAvailable_Request {
            etype: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional bool available = 1;

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

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

    pub fn has_available(&self) -> bool {
        self.available.is_some()
    }

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

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

    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.available = ::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.available {
            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.available {
            os.write_bool(1, 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() -> CSteamOSManager_IsTelemetryHelperAvailable_Response {
        CSteamOSManager_IsTelemetryHelperAvailable_Response::new()
    }

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

    fn default_instance() -> &'static CSteamOSManager_IsTelemetryHelperAvailable_Response {
        static instance: CSteamOSManager_IsTelemetryHelperAvailable_Response = CSteamOSManager_IsTelemetryHelperAvailable_Response {
            available: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSManager_OptOutOfSideloadedClient_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSManager_OptOutOfSideloadedClient_Request {
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSManager_OptOutOfSideloadedClient_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

    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 {
                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;
        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<()> {
        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() -> CSteamOSManager_OptOutOfSideloadedClient_Request {
        CSteamOSManager_OptOutOfSideloadedClient_Request::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSManager_OptOutOfSideloadedClient_Request {
        static instance: CSteamOSManager_OptOutOfSideloadedClient_Request = CSteamOSManager_OptOutOfSideloadedClient_Request {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSManager_OptOutOfSideloadedClient_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSManager_OptOutOfSideloadedClient_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSManager_OptOutOfSideloadedClient_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

    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 {
                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;
        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<()> {
        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() -> CSteamOSManager_OptOutOfSideloadedClient_Response {
        CSteamOSManager_OptOutOfSideloadedClient_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSManager_OptOutOfSideloadedClient_Response {
        static instance: CSteamOSManager_OptOutOfSideloadedClient_Response = CSteamOSManager_OptOutOfSideloadedClient_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSManager_ApplyMandatoryUpdate_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSManager_ApplyMandatoryUpdate_Request {
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSManager_ApplyMandatoryUpdate_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

    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 {
                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;
        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<()> {
        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() -> CSteamOSManager_ApplyMandatoryUpdate_Request {
        CSteamOSManager_ApplyMandatoryUpdate_Request::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSManager_ApplyMandatoryUpdate_Request {
        static instance: CSteamOSManager_ApplyMandatoryUpdate_Request = CSteamOSManager_ApplyMandatoryUpdate_Request {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSManager_ApplyMandatoryUpdate_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSManager_ApplyMandatoryUpdate_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSManager_ApplyMandatoryUpdate_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

    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 {
                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;
        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<()> {
        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() -> CSteamOSManager_ApplyMandatoryUpdate_Response {
        CSteamOSManager_ApplyMandatoryUpdate_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSManager_ApplyMandatoryUpdate_Response {
        static instance: CSteamOSManager_ApplyMandatoryUpdate_Response = CSteamOSManager_ApplyMandatoryUpdate_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSManager_FactoryReset_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSManager_FactoryReset_Request {
    // message fields
    // @@protoc_insertion_point(field:CSteamOSManager_FactoryReset_Request.reset_os)
    pub reset_os: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSManager_FactoryReset_Request.reset_user_data)
    pub reset_user_data: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSManager_FactoryReset_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional bool reset_os = 1;

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

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

    pub fn has_reset_os(&self) -> bool {
        self.reset_os.is_some()
    }

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

    // optional bool reset_user_data = 2;

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

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

    pub fn has_reset_user_data(&self) -> bool {
        self.reset_user_data.is_some()
    }

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

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

    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.reset_os = ::std::option::Option::Some(is.read_bool()?);
                },
                16 => {
                    self.reset_user_data = ::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.reset_os {
            my_size += 1 + 1;
        }
        if let Some(v) = self.reset_user_data {
            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.reset_os {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.reset_user_data {
            os.write_bool(2, 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() -> CSteamOSManager_FactoryReset_Request {
        CSteamOSManager_FactoryReset_Request::new()
    }

    fn clear(&mut self) {
        self.reset_os = ::std::option::Option::None;
        self.reset_user_data = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSManager_FactoryReset_Request {
        static instance: CSteamOSManager_FactoryReset_Request = CSteamOSManager_FactoryReset_Request {
            reset_os: ::std::option::Option::None,
            reset_user_data: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSManager_FactoryReset_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSManager_FactoryReset_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSManager_FactoryReset_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

    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 {
                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;
        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<()> {
        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() -> CSteamOSManager_FactoryReset_Response {
        CSteamOSManager_FactoryReset_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSManager_FactoryReset_Response {
        static instance: CSteamOSManager_FactoryReset_Response = CSteamOSManager_FactoryReset_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSSLSPlugin)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSSLSPlugin {
    // message fields
    // @@protoc_insertion_point(field:CSteamOSSLSPlugin.etype)
    pub etype: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::enums::ESLSHelper>>,
    // @@protoc_insertion_point(field:CSteamOSSLSPlugin.is_available)
    pub is_available: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSSLSPlugin.is_enabled)
    pub is_enabled: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSSLSPlugin.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional .ESLSHelper etype = 1;

    pub fn etype(&self) -> super::enums::ESLSHelper {
        match self.etype {
            Some(e) => e.enum_value_or(super::enums::ESLSHelper::k_ESLSHelper_Invalid),
            None => super::enums::ESLSHelper::k_ESLSHelper_Invalid,
        }
    }

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

    pub fn has_etype(&self) -> bool {
        self.etype.is_some()
    }

    // Param is passed by value, moved
    pub fn set_etype(&mut self, v: super::enums::ESLSHelper) {
        self.etype = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional bool is_available = 2;

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

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

    pub fn has_is_available(&self) -> bool {
        self.is_available.is_some()
    }

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

    // optional bool is_enabled = 3;

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

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

    pub fn has_is_enabled(&self) -> bool {
        self.is_enabled.is_some()
    }

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

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

    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.etype = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                16 => {
                    self.is_available = ::std::option::Option::Some(is.read_bool()?);
                },
                24 => {
                    self.is_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.etype {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v.value());
        }
        if let Some(v) = self.is_available {
            my_size += 1 + 1;
        }
        if let Some(v) = self.is_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.etype {
            os.write_enum(1, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.is_available {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.is_enabled {
            os.write_bool(3, 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() -> CSteamOSSLSPlugin {
        CSteamOSSLSPlugin::new()
    }

    fn clear(&mut self) {
        self.etype = ::std::option::Option::None;
        self.is_available = ::std::option::Option::None;
        self.is_enabled = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSSLSPlugin {
        static instance: CSteamOSSLSPlugin = CSteamOSSLSPlugin {
            etype: ::std::option::Option::None,
            is_available: ::std::option::Option::None,
            is_enabled: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSSLSState)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSSLSState {
    // message fields
    // @@protoc_insertion_point(field:CSteamOSSLSState.is_available)
    pub is_available: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSSLSState.is_enabled)
    pub is_enabled: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CSteamOSSLSState.plugins)
    pub plugins: ::std::vec::Vec<CSteamOSSLSPlugin>,
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSSLSState.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional bool is_available = 1;

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

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

    pub fn has_is_available(&self) -> bool {
        self.is_available.is_some()
    }

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

    // optional bool is_enabled = 2;

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

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

    pub fn has_is_enabled(&self) -> bool {
        self.is_enabled.is_some()
    }

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

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

    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.is_available = ::std::option::Option::Some(is.read_bool()?);
                },
                16 => {
                    self.is_enabled = ::std::option::Option::Some(is.read_bool()?);
                },
                26 => {
                    self.plugins.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.is_available {
            my_size += 1 + 1;
        }
        if let Some(v) = self.is_enabled {
            my_size += 1 + 1;
        }
        for value in &self.plugins {
            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.is_available {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.is_enabled {
            os.write_bool(2, v)?;
        }
        for v in &self.plugins {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, 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() -> CSteamOSSLSState {
        CSteamOSSLSState::new()
    }

    fn clear(&mut self) {
        self.is_available = ::std::option::Option::None;
        self.is_enabled = ::std::option::Option::None;
        self.plugins.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSSLSState {
        static instance: CSteamOSSLSState = CSteamOSSLSState {
            is_available: ::std::option::Option::None,
            is_enabled: ::std::option::Option::None,
            plugins: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSSLS_GetState_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSSLS_GetState_Request {
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSSLS_GetState_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

    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 {
                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;
        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<()> {
        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() -> CSteamOSSLS_GetState_Request {
        CSteamOSSLS_GetState_Request::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSSLS_GetState_Request {
        static instance: CSteamOSSLS_GetState_Request = CSteamOSSLS_GetState_Request {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSSLS_GetState_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSSLS_GetState_Response {
    // message fields
    // @@protoc_insertion_point(field:CSteamOSSLS_GetState_Response.state)
    pub state: ::steam_vent_proto_common::protobuf::MessageField<CSteamOSSLSState>,
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSSLS_GetState_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

    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 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.state)?;
                },
                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.state.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.state.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, 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() -> CSteamOSSLS_GetState_Response {
        CSteamOSSLS_GetState_Response::new()
    }

    fn clear(&mut self) {
        self.state.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSSLS_GetState_Response {
        static instance: CSteamOSSLS_GetState_Response = CSteamOSSLS_GetState_Response {
            state: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSSLS_StateChanged_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSSLS_StateChanged_Notification {
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSSLS_StateChanged_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

    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 {
                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;
        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<()> {
        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() -> CSteamOSSLS_StateChanged_Notification {
        CSteamOSSLS_StateChanged_Notification::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSSLS_StateChanged_Notification {
        static instance: CSteamOSSLS_StateChanged_Notification = CSteamOSSLS_StateChanged_Notification {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional bool enabled = 1;

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

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

    pub fn has_enabled(&self) -> bool {
        self.enabled.is_some()
    }

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

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

    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.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.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.enabled {
            os.write_bool(1, 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() -> CSteamOSSLS_SetEnabled_Request {
        CSteamOSSLS_SetEnabled_Request::new()
    }

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

    fn default_instance() -> &'static CSteamOSSLS_SetEnabled_Request {
        static instance: CSteamOSSLS_SetEnabled_Request = CSteamOSSLS_SetEnabled_Request {
            enabled: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSSLS_SetEnabled_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSSLS_SetEnabled_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSSLS_SetEnabled_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

    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 {
                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;
        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<()> {
        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() -> CSteamOSSLS_SetEnabled_Response {
        CSteamOSSLS_SetEnabled_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSSLS_SetEnabled_Response {
        static instance: CSteamOSSLS_SetEnabled_Response = CSteamOSSLS_SetEnabled_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSSLS_SetPluginEnabled_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSSLS_SetPluginEnabled_Request {
    // message fields
    // @@protoc_insertion_point(field:CSteamOSSLS_SetPluginEnabled_Request.etype)
    pub etype: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::enums::ESLSHelper>>,
    // @@protoc_insertion_point(field:CSteamOSSLS_SetPluginEnabled_Request.enabled)
    pub enabled: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSSLS_SetPluginEnabled_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional .ESLSHelper etype = 1;

    pub fn etype(&self) -> super::enums::ESLSHelper {
        match self.etype {
            Some(e) => e.enum_value_or(super::enums::ESLSHelper::k_ESLSHelper_Invalid),
            None => super::enums::ESLSHelper::k_ESLSHelper_Invalid,
        }
    }

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

    pub fn has_etype(&self) -> bool {
        self.etype.is_some()
    }

    // Param is passed by value, moved
    pub fn set_etype(&mut self, v: super::enums::ESLSHelper) {
        self.etype = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional bool enabled = 2;

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

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

    pub fn has_enabled(&self) -> bool {
        self.enabled.is_some()
    }

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

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

    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.etype = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                16 => {
                    self.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.etype {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v.value());
        }
        if let Some(v) = self.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.etype {
            os.write_enum(1, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.enabled {
            os.write_bool(2, 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() -> CSteamOSSLS_SetPluginEnabled_Request {
        CSteamOSSLS_SetPluginEnabled_Request::new()
    }

    fn clear(&mut self) {
        self.etype = ::std::option::Option::None;
        self.enabled = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSSLS_SetPluginEnabled_Request {
        static instance: CSteamOSSLS_SetPluginEnabled_Request = CSteamOSSLS_SetPluginEnabled_Request {
            etype: ::std::option::Option::None,
            enabled: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CSteamOSSLS_SetPluginEnabled_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSteamOSSLS_SetPluginEnabled_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CSteamOSSLS_SetPluginEnabled_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

    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 {
                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;
        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<()> {
        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() -> CSteamOSSLS_SetPluginEnabled_Response {
        CSteamOSSLS_SetPluginEnabled_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSteamOSSLS_SetPluginEnabled_Response {
        static instance: CSteamOSSLS_SetPluginEnabled_Response = CSteamOSSLS_SetPluginEnabled_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}


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

#[allow(unused_imports)]
use crate::enums::*;
#[allow(unused_imports)]
use crate::steammessages_base::*;
#[allow(unused_imports)]
use crate::webuimessages_base::*;
impl ::steam_vent_proto_common::RpcMessage for CMsgFactoryResetState {
    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 CSteamOSManagerState {
    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 CSteamOSManager_GetState_Request {
    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 CSteamOSManager_GetState_Response {
    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 CSteamOSManager_StateChanged_Notification {
    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 CSteamOSManager_IsTelemetryHelperAvailable_Request {
    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 CSteamOSManager_IsTelemetryHelperAvailable_Response {
    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 CSteamOSManager_OptOutOfSideloadedClient_Request {
    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 CSteamOSManager_OptOutOfSideloadedClient_Response {
    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 CSteamOSManager_ApplyMandatoryUpdate_Request {
    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 CSteamOSManager_ApplyMandatoryUpdate_Response {
    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 CSteamOSManager_FactoryReset_Request {
    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 CSteamOSManager_FactoryReset_Response {
    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 CSteamOSSLSPlugin {
    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 CSteamOSSLSState {
    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 CSteamOSSLS_GetState_Request {
    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 CSteamOSSLS_GetState_Response {
    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 CSteamOSSLS_StateChanged_Notification {
    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 CSteamOSSLS_SetEnabled_Request {
    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 CSteamOSSLS_SetEnabled_Response {
    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 CSteamOSSLS_SetPluginEnabled_Request {
    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 CSteamOSSLS_SetPluginEnabled_Response {
    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
    }
}
///
struct SteamOSManager {}
impl ::steam_vent_proto_common::RpcService for SteamOSManager {
    const SERVICE_NAME: &'static str = "SteamOSManager";
}
///
struct SteamOSSLS {}
impl ::steam_vent_proto_common::RpcService for SteamOSSLS {
    const SERVICE_NAME: &'static str = "SteamOSSLS";
}
impl ::steam_vent_proto_common::RpcMethod
for CSteamOSManager_ApplyMandatoryUpdate_Request {
    const METHOD_NAME: &'static str = "SteamOSManager.ApplyMandatoryUpdate#1";
    type Response = CSteamOSManager_ApplyMandatoryUpdate_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CSteamOSManager_FactoryReset_Request {
    const METHOD_NAME: &'static str = "SteamOSManager.FactoryReset#1";
    type Response = CSteamOSManager_FactoryReset_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CSteamOSManager_GetState_Request {
    const METHOD_NAME: &'static str = "SteamOSManager.GetState#1";
    type Response = CSteamOSManager_GetState_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CSteamOSManager_OptOutOfSideloadedClient_Request {
    const METHOD_NAME: &'static str = "SteamOSManager.OptOutOfSideloadedClient#1";
    type Response = CSteamOSManager_OptOutOfSideloadedClient_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CSteamOSManager_StateChanged_Notification {
    const METHOD_NAME: &'static str = "SteamOSManager.NotifyStateChanged#1";
    type Response = WebUINoResponse;
}
impl ::steam_vent_proto_common::RpcMethod for CSteamOSSLS_GetState_Request {
    const METHOD_NAME: &'static str = "SteamOSSLS.GetState#1";
    type Response = CSteamOSSLS_GetState_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CSteamOSSLS_SetEnabled_Request {
    const METHOD_NAME: &'static str = "SteamOSSLS.SetEnabled#1";
    type Response = CSteamOSSLS_SetEnabled_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CSteamOSSLS_SetPluginEnabled_Request {
    const METHOD_NAME: &'static str = "SteamOSSLS.SetPluginEnabled#1";
    type Response = CSteamOSSLS_SetPluginEnabled_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CSteamOSSLS_StateChanged_Notification {
    const METHOD_NAME: &'static str = "SteamOSSLS.NotifyStateChanged#1";
    type Response = WebUINoResponse;
}
