// This file is generated by rust-protobuf 3.5.1. Do not edit
// .proto file is parsed by pure
// @generated

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

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

#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]

//! Generated file from `steammessages_siteserverui.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:SiteServerUI_Login_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SiteServerUI_Login_Request {
    // message fields
    // @@protoc_insertion_point(field:SiteServerUI_Login_Request.username)
    pub username: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:SiteServerUI_Login_Request.password)
    pub password: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:SiteServerUI_Login_Request.steamguardcode)
    pub steamguardcode: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:SiteServerUI_Login_Request.remember_password)
    pub remember_password: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:SiteServerUI_Login_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string username = 1;

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

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

    pub fn has_username(&self) -> bool {
        self.username.is_some()
    }

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

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

    // optional string password = 2;

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

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

    pub fn has_password(&self) -> bool {
        self.password.is_some()
    }

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

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

    // optional string steamguardcode = 3;

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

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

    pub fn has_steamguardcode(&self) -> bool {
        self.steamguardcode.is_some()
    }

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

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

    // optional bool remember_password = 4;

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

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

    pub fn has_remember_password(&self) -> bool {
        self.remember_password.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Login_Request {
    const NAME: &'static str = "SiteServerUI_Login_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 {
                10 => {
                    self.username = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.password = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    self.steamguardcode = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.remember_password = ::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.username.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.password.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.steamguardcode.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.remember_password {
            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.username.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.password.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.steamguardcode.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.remember_password {
            os.write_bool(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() -> SiteServerUI_Login_Request {
        SiteServerUI_Login_Request::new()
    }

    fn clear(&mut self) {
        self.username = ::std::option::Option::None;
        self.password = ::std::option::Option::None;
        self.steamguardcode = ::std::option::Option::None;
        self.remember_password = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static SiteServerUI_Login_Request {
        static instance: SiteServerUI_Login_Request = SiteServerUI_Login_Request {
            username: ::std::option::Option::None,
            password: ::std::option::Option::None,
            steamguardcode: ::std::option::Option::None,
            remember_password: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional int32 logon_state = 1;

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

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

    pub fn has_logon_state(&self) -> bool {
        self.logon_state.is_some()
    }

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

    // optional int32 logon_eresult = 2;

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

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

    pub fn has_logon_eresult(&self) -> bool {
        self.logon_eresult.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Login_Response {
    const NAME: &'static str = "SiteServerUI_Login_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.logon_state = ::std::option::Option::Some(is.read_int32()?);
                },
                16 => {
                    self.logon_eresult = ::std::option::Option::Some(is.read_int32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.logon_state {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.logon_eresult {
            os.write_int32(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() -> SiteServerUI_Login_Response {
        SiteServerUI_Login_Response::new()
    }

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

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_LoginStatus_Request {
    const NAME: &'static str = "SiteServerUI_LoginStatus_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() -> SiteServerUI_LoginStatus_Request {
        SiteServerUI_LoginStatus_Request::new()
    }

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

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

// @@protoc_insertion_point(message:SiteServerUI_LoginStatus_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SiteServerUI_LoginStatus_Response {
    // message fields
    // @@protoc_insertion_point(field:SiteServerUI_LoginStatus_Response.username)
    pub username: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:SiteServerUI_LoginStatus_Response.cached_credentials)
    pub cached_credentials: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:SiteServerUI_LoginStatus_Response.logon_state)
    pub logon_state: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:SiteServerUI_LoginStatus_Response.logon_eresult)
    pub logon_eresult: ::std::option::Option<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:SiteServerUI_LoginStatus_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string username = 1;

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

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

    pub fn has_username(&self) -> bool {
        self.username.is_some()
    }

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

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

    // optional bool cached_credentials = 2;

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

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

    pub fn has_cached_credentials(&self) -> bool {
        self.cached_credentials.is_some()
    }

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

    // optional int32 logon_state = 3;

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

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

    pub fn has_logon_state(&self) -> bool {
        self.logon_state.is_some()
    }

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

    // optional int32 logon_eresult = 4;

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

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

    pub fn has_logon_eresult(&self) -> bool {
        self.logon_eresult.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_LoginStatus_Response {
    const NAME: &'static str = "SiteServerUI_LoginStatus_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 => {
                    self.username = ::std::option::Option::Some(is.read_string()?);
                },
                16 => {
                    self.cached_credentials = ::std::option::Option::Some(is.read_bool()?);
                },
                24 => {
                    self.logon_state = ::std::option::Option::Some(is.read_int32()?);
                },
                32 => {
                    self.logon_eresult = ::std::option::Option::Some(is.read_int32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.username.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.cached_credentials {
            my_size += 1 + 1;
        }
        if let Some(v) = self.logon_state {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v);
        }
        if let Some(v) = self.logon_eresult {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.username.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.cached_credentials {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.logon_state {
            os.write_int32(3, v)?;
        }
        if let Some(v) = self.logon_eresult {
            os.write_int32(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() -> SiteServerUI_LoginStatus_Response {
        SiteServerUI_LoginStatus_Response::new()
    }

    fn clear(&mut self) {
        self.username = ::std::option::Option::None;
        self.cached_credentials = ::std::option::Option::None;
        self.logon_state = ::std::option::Option::None;
        self.logon_eresult = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static SiteServerUI_LoginStatus_Response {
        static instance: SiteServerUI_LoginStatus_Response = SiteServerUI_LoginStatus_Response {
            username: ::std::option::Option::None,
            cached_credentials: ::std::option::Option::None,
            logon_state: ::std::option::Option::None,
            logon_eresult: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_CancelLogin_Request {
    const NAME: &'static str = "SiteServerUI_CancelLogin_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() -> SiteServerUI_CancelLogin_Request {
        SiteServerUI_CancelLogin_Request::new()
    }

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

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

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

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

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

    // optional int32 logon_state = 1;

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

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

    pub fn has_logon_state(&self) -> bool {
        self.logon_state.is_some()
    }

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

    // optional int32 logon_eresult = 2;

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

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

    pub fn has_logon_eresult(&self) -> bool {
        self.logon_eresult.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_CancelLogin_Response {
    const NAME: &'static str = "SiteServerUI_CancelLogin_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.logon_state = ::std::option::Option::Some(is.read_int32()?);
                },
                16 => {
                    self.logon_eresult = ::std::option::Option::Some(is.read_int32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.logon_state {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.logon_eresult {
            os.write_int32(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() -> SiteServerUI_CancelLogin_Response {
        SiteServerUI_CancelLogin_Response::new()
    }

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

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Logout_Request {
    const NAME: &'static str = "SiteServerUI_Logout_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() -> SiteServerUI_Logout_Request {
        SiteServerUI_Logout_Request::new()
    }

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

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

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

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

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

    // optional int32 logon_state = 1;

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

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

    pub fn has_logon_state(&self) -> bool {
        self.logon_state.is_some()
    }

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

    // optional int32 logout_eresult = 2;

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

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

    pub fn has_logout_eresult(&self) -> bool {
        self.logout_eresult.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Logout_Response {
    const NAME: &'static str = "SiteServerUI_Logout_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.logon_state = ::std::option::Option::Some(is.read_int32()?);
                },
                16 => {
                    self.logout_eresult = ::std::option::Option::Some(is.read_int32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.logon_state {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.logout_eresult {
            os.write_int32(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() -> SiteServerUI_Logout_Response {
        SiteServerUI_Logout_Response::new()
    }

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

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

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

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

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

    // optional bool restart = 1;

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

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

    pub fn has_restart(&self) -> bool {
        self.restart.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Quit_Request {
    const NAME: &'static str = "SiteServerUI_Quit_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.restart = ::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.restart {
            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.restart {
            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() -> SiteServerUI_Quit_Request {
        SiteServerUI_Quit_Request::new()
    }

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

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Quit_Response {
    const NAME: &'static str = "SiteServerUI_Quit_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() -> SiteServerUI_Quit_Response {
        SiteServerUI_Quit_Response::new()
    }

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

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Status_Request {
    const NAME: &'static str = "SiteServerUI_Status_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() -> SiteServerUI_Status_Request {
        SiteServerUI_Status_Request::new()
    }

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

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

// @@protoc_insertion_point(message:SiteServerUI_Status_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SiteServerUI_Status_Response {
    // message fields
    // @@protoc_insertion_point(field:SiteServerUI_Status_Response.logon_state)
    pub logon_state: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:SiteServerUI_Status_Response.logon_eresult)
    pub logon_eresult: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:SiteServerUI_Status_Response.connected)
    pub connected: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:SiteServerUI_Status_Response.cache_enabled)
    pub cache_enabled: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:SiteServerUI_Status_Response.acct_status)
    pub acct_status: ::std::option::Option<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:SiteServerUI_Status_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional int32 logon_state = 1;

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

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

    pub fn has_logon_state(&self) -> bool {
        self.logon_state.is_some()
    }

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

    // optional int32 logon_eresult = 2;

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

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

    pub fn has_logon_eresult(&self) -> bool {
        self.logon_eresult.is_some()
    }

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

    // optional bool connected = 3;

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

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

    pub fn has_connected(&self) -> bool {
        self.connected.is_some()
    }

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

    // optional bool cache_enabled = 4;

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

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

    pub fn has_cache_enabled(&self) -> bool {
        self.cache_enabled.is_some()
    }

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

    // optional int32 acct_status = 5;

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

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

    pub fn has_acct_status(&self) -> bool {
        self.acct_status.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Status_Response {
    const NAME: &'static str = "SiteServerUI_Status_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.logon_state = ::std::option::Option::Some(is.read_int32()?);
                },
                16 => {
                    self.logon_eresult = ::std::option::Option::Some(is.read_int32()?);
                },
                24 => {
                    self.connected = ::std::option::Option::Some(is.read_bool()?);
                },
                32 => {
                    self.cache_enabled = ::std::option::Option::Some(is.read_bool()?);
                },
                40 => {
                    self.acct_status = ::std::option::Option::Some(is.read_int32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.logon_state {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
        }
        if let Some(v) = self.logon_eresult {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
        }
        if let Some(v) = self.connected {
            my_size += 1 + 1;
        }
        if let Some(v) = self.cache_enabled {
            my_size += 1 + 1;
        }
        if let Some(v) = self.acct_status {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.logon_state {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.logon_eresult {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.connected {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.cache_enabled {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.acct_status {
            os.write_int32(5, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.logon_state = ::std::option::Option::None;
        self.logon_eresult = ::std::option::Option::None;
        self.connected = ::std::option::Option::None;
        self.cache_enabled = ::std::option::Option::None;
        self.acct_status = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static SiteServerUI_Status_Response {
        static instance: SiteServerUI_Status_Response = SiteServerUI_Status_Response {
            logon_state: ::std::option::Option::None,
            logon_eresult: ::std::option::Option::None,
            connected: ::std::option::Option::None,
            cache_enabled: ::std::option::Option::None,
            acct_status: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_GetLanguage_Request {
    const NAME: &'static str = "SiteServerUI_GetLanguage_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() -> SiteServerUI_GetLanguage_Request {
        SiteServerUI_GetLanguage_Request::new()
    }

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

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

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

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

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

    // optional string language = 1;

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

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

    pub fn has_language(&self) -> bool {
        self.language.is_some()
    }

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

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_GetLanguage_Response {
    const NAME: &'static str = "SiteServerUI_GetLanguage_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 => {
                    self.language = ::std::option::Option::Some(is.read_string()?);
                },
                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.language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.language.as_ref() {
            os.write_string(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() -> SiteServerUI_GetLanguage_Response {
        SiteServerUI_GetLanguage_Response::new()
    }

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

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

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

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

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

    // optional string language = 1;

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

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

    pub fn has_language(&self) -> bool {
        self.language.is_some()
    }

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

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_SetLanguage_Request {
    const NAME: &'static str = "SiteServerUI_SetLanguage_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 {
                10 => {
                    self.language = ::std::option::Option::Some(is.read_string()?);
                },
                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.language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.language.as_ref() {
            os.write_string(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() -> SiteServerUI_SetLanguage_Request {
        SiteServerUI_SetLanguage_Request::new()
    }

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

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_SetLanguage_Response {
    const NAME: &'static str = "SiteServerUI_SetLanguage_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() -> SiteServerUI_SetLanguage_Response {
        SiteServerUI_SetLanguage_Response::new()
    }

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

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_ClientStatus_Request {
    const NAME: &'static str = "SiteServerUI_ClientStatus_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() -> SiteServerUI_ClientStatus_Request {
        SiteServerUI_ClientStatus_Request::new()
    }

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

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

// @@protoc_insertion_point(message:SiteServerUI_ClientStatus_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SiteServerUI_ClientStatus_Response {
    // message fields
    // @@protoc_insertion_point(field:SiteServerUI_ClientStatus_Response.clients)
    pub clients: ::std::vec::Vec<site_server_ui_client_status_response::ClientInfo>,
    // @@protoc_insertion_point(field:SiteServerUI_ClientStatus_Response.payments)
    pub payments: ::std::vec::Vec<site_server_ui_client_status_response::Payment>,
    // special fields
    // @@protoc_insertion_point(special_field:SiteServerUI_ClientStatus_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_ClientStatus_Response {
    const NAME: &'static str = "SiteServerUI_ClientStatus_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 {
                34 => {
                    self.clients.push(is.read_message()?);
                },
                42 => {
                    self.payments.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;
        for value in &self.clients {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.payments {
            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<()> {
        for v in &self.clients {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        for v in &self.payments {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

    fn default_instance() -> &'static SiteServerUI_ClientStatus_Response {
        static instance: SiteServerUI_ClientStatus_Response = SiteServerUI_ClientStatus_Response {
            clients: ::std::vec::Vec::new(),
            payments: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `SiteServerUI_ClientStatus_Response`
pub mod site_server_ui_client_status_response {
    // @@protoc_insertion_point(message:SiteServerUI_ClientStatus_Response.ClientInfo)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct ClientInfo {
        // message fields
        // @@protoc_insertion_point(field:SiteServerUI_ClientStatus_Response.ClientInfo.ip)
        pub ip: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:SiteServerUI_ClientStatus_Response.ClientInfo.hostname)
        pub hostname: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:SiteServerUI_ClientStatus_Response.ClientInfo.connected)
        pub connected: ::std::option::Option<bool>,
        // @@protoc_insertion_point(field:SiteServerUI_ClientStatus_Response.ClientInfo.instance_id)
        pub instance_id: ::std::option::Option<u64>,
        // special fields
        // @@protoc_insertion_point(special_field:SiteServerUI_ClientStatus_Response.ClientInfo.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional uint32 ip = 1;

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

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

        pub fn has_ip(&self) -> bool {
            self.ip.is_some()
        }

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

        // optional string hostname = 2;

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

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

        pub fn has_hostname(&self) -> bool {
            self.hostname.is_some()
        }

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

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

        // optional bool connected = 3;

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

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

        pub fn has_connected(&self) -> bool {
            self.connected.is_some()
        }

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

        // optional uint64 instance_id = 4;

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

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

        pub fn has_instance_id(&self) -> bool {
            self.instance_id.is_some()
        }

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

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

        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.ip = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    18 => {
                        self.hostname = ::std::option::Option::Some(is.read_string()?);
                    },
                    24 => {
                        self.connected = ::std::option::Option::Some(is.read_bool()?);
                    },
                    32 => {
                        self.instance_id = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    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.ip {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
            }
            if let Some(v) = self.hostname.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
            }
            if let Some(v) = self.connected {
                my_size += 1 + 1;
            }
            if let Some(v) = self.instance_id {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(4, v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.ip {
                os.write_uint32(1, v)?;
            }
            if let Some(v) = self.hostname.as_ref() {
                os.write_string(2, v)?;
            }
            if let Some(v) = self.connected {
                os.write_bool(3, v)?;
            }
            if let Some(v) = self.instance_id {
                os.write_uint64(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() -> ClientInfo {
            ClientInfo::new()
        }

        fn clear(&mut self) {
            self.ip = ::std::option::Option::None;
            self.hostname = ::std::option::Option::None;
            self.connected = ::std::option::Option::None;
            self.instance_id = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static ClientInfo {
            static instance: ClientInfo = ClientInfo {
                ip: ::std::option::Option::None,
                hostname: ::std::option::Option::None,
                connected: ::std::option::Option::None,
                instance_id: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:SiteServerUI_ClientStatus_Response.Payment)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Payment {
        // message fields
        // @@protoc_insertion_point(field:SiteServerUI_ClientStatus_Response.Payment.transid)
        pub transid: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:SiteServerUI_ClientStatus_Response.Payment.steamid)
        pub steamid: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:SiteServerUI_ClientStatus_Response.Payment.amount)
        pub amount: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:SiteServerUI_ClientStatus_Response.Payment.time_created)
        pub time_created: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:SiteServerUI_ClientStatus_Response.Payment.purchase_status)
        pub purchase_status: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:SiteServerUI_ClientStatus_Response.Payment.hostname)
        pub hostname: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:SiteServerUI_ClientStatus_Response.Payment.persona_name)
        pub persona_name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:SiteServerUI_ClientStatus_Response.Payment.profile_url)
        pub profile_url: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:SiteServerUI_ClientStatus_Response.Payment.avatar_url)
        pub avatar_url: ::std::option::Option<::std::string::String>,
        // special fields
        // @@protoc_insertion_point(special_field:SiteServerUI_ClientStatus_Response.Payment.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional uint64 transid = 1;

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

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

        pub fn has_transid(&self) -> bool {
            self.transid.is_some()
        }

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

        // optional uint64 steamid = 2;

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

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

        pub fn has_steamid(&self) -> bool {
            self.steamid.is_some()
        }

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

        // optional string amount = 3;

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

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

        pub fn has_amount(&self) -> bool {
            self.amount.is_some()
        }

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

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

        // optional int32 time_created = 4;

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

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

        pub fn has_time_created(&self) -> bool {
            self.time_created.is_some()
        }

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

        // optional int32 purchase_status = 5;

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

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

        pub fn has_purchase_status(&self) -> bool {
            self.purchase_status.is_some()
        }

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

        // optional string hostname = 6;

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

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

        pub fn has_hostname(&self) -> bool {
            self.hostname.is_some()
        }

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

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

        // optional string persona_name = 7;

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

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

        pub fn has_persona_name(&self) -> bool {
            self.persona_name.is_some()
        }

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

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

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

        // optional string profile_url = 8;

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

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

        pub fn has_profile_url(&self) -> bool {
            self.profile_url.is_some()
        }

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

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

        // optional string avatar_url = 9;

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

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

        pub fn has_avatar_url(&self) -> bool {
            self.avatar_url.is_some()
        }

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

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

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

        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.transid = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    16 => {
                        self.steamid = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    26 => {
                        self.amount = ::std::option::Option::Some(is.read_string()?);
                    },
                    32 => {
                        self.time_created = ::std::option::Option::Some(is.read_int32()?);
                    },
                    40 => {
                        self.purchase_status = ::std::option::Option::Some(is.read_int32()?);
                    },
                    50 => {
                        self.hostname = ::std::option::Option::Some(is.read_string()?);
                    },
                    58 => {
                        self.persona_name = ::std::option::Option::Some(is.read_string()?);
                    },
                    66 => {
                        self.profile_url = ::std::option::Option::Some(is.read_string()?);
                    },
                    74 => {
                        self.avatar_url = ::std::option::Option::Some(is.read_string()?);
                    },
                    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.transid {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
            }
            if let Some(v) = self.steamid {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
            }
            if let Some(v) = self.amount.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
            }
            if let Some(v) = self.time_created {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v);
            }
            if let Some(v) = self.purchase_status {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v);
            }
            if let Some(v) = self.hostname.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
            }
            if let Some(v) = self.persona_name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
            }
            if let Some(v) = self.profile_url.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(8, &v);
            }
            if let Some(v) = self.avatar_url.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.transid {
                os.write_uint64(1, v)?;
            }
            if let Some(v) = self.steamid {
                os.write_uint64(2, v)?;
            }
            if let Some(v) = self.amount.as_ref() {
                os.write_string(3, v)?;
            }
            if let Some(v) = self.time_created {
                os.write_int32(4, v)?;
            }
            if let Some(v) = self.purchase_status {
                os.write_int32(5, v)?;
            }
            if let Some(v) = self.hostname.as_ref() {
                os.write_string(6, v)?;
            }
            if let Some(v) = self.persona_name.as_ref() {
                os.write_string(7, v)?;
            }
            if let Some(v) = self.profile_url.as_ref() {
                os.write_string(8, v)?;
            }
            if let Some(v) = self.avatar_url.as_ref() {
                os.write_string(9, 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() -> Payment {
            Payment::new()
        }

        fn clear(&mut self) {
            self.transid = ::std::option::Option::None;
            self.steamid = ::std::option::Option::None;
            self.amount = ::std::option::Option::None;
            self.time_created = ::std::option::Option::None;
            self.purchase_status = ::std::option::Option::None;
            self.hostname = ::std::option::Option::None;
            self.persona_name = ::std::option::Option::None;
            self.profile_url = ::std::option::Option::None;
            self.avatar_url = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Payment {
            static instance: Payment = Payment {
                transid: ::std::option::Option::None,
                steamid: ::std::option::Option::None,
                amount: ::std::option::Option::None,
                time_created: ::std::option::Option::None,
                purchase_status: ::std::option::Option::None,
                hostname: ::std::option::Option::None,
                persona_name: ::std::option::Option::None,
                profile_url: ::std::option::Option::None,
                avatar_url: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_ContentCacheStatus_Request {
    const NAME: &'static str = "SiteServerUI_ContentCacheStatus_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() -> SiteServerUI_ContentCacheStatus_Request {
        SiteServerUI_ContentCacheStatus_Request::new()
    }

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

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

// @@protoc_insertion_point(message:SiteServerUI_ContentCacheStatus_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SiteServerUI_ContentCacheStatus_Response {
    // message fields
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheStatus_Response.enabled)
    pub enabled: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheStatus_Response.port)
    pub port: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheStatus_Response.cache_location)
    pub cache_location: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheStatus_Response.max_size_gb)
    pub max_size_gb: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheStatus_Response.p2p_enabled)
    pub p2p_enabled: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheStatus_Response.explicit_ip_address)
    pub explicit_ip_address: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheStatus_Response.external_process)
    pub external_process: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheStatus_Response.current_size_gb)
    pub current_size_gb: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheStatus_Response.current_bw)
    pub current_bw: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheStatus_Response.total_bytes_served)
    pub total_bytes_served: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:SiteServerUI_ContentCacheStatus_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl SiteServerUI_ContentCacheStatus_Response {
    pub fn new() -> SiteServerUI_ContentCacheStatus_Response {
        ::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);
    }

    // optional uint32 port = 2;

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

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

    pub fn has_port(&self) -> bool {
        self.port.is_some()
    }

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

    // optional string cache_location = 3;

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

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

    pub fn has_cache_location(&self) -> bool {
        self.cache_location.is_some()
    }

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

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

    // optional uint32 max_size_gb = 4;

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

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

    pub fn has_max_size_gb(&self) -> bool {
        self.max_size_gb.is_some()
    }

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

    // optional bool p2p_enabled = 5;

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

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

    pub fn has_p2p_enabled(&self) -> bool {
        self.p2p_enabled.is_some()
    }

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

    // optional string explicit_ip_address = 9;

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

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

    pub fn has_explicit_ip_address(&self) -> bool {
        self.explicit_ip_address.is_some()
    }

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

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

    // optional bool external_process = 10;

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

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

    pub fn has_external_process(&self) -> bool {
        self.external_process.is_some()
    }

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

    // optional uint32 current_size_gb = 6;

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

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

    pub fn has_current_size_gb(&self) -> bool {
        self.current_size_gb.is_some()
    }

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

    // optional uint64 current_bw = 7;

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

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

    pub fn has_current_bw(&self) -> bool {
        self.current_bw.is_some()
    }

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

    // optional uint64 total_bytes_served = 8;

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

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

    pub fn has_total_bytes_served(&self) -> bool {
        self.total_bytes_served.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_ContentCacheStatus_Response {
    const NAME: &'static str = "SiteServerUI_ContentCacheStatus_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.enabled = ::std::option::Option::Some(is.read_bool()?);
                },
                16 => {
                    self.port = ::std::option::Option::Some(is.read_uint32()?);
                },
                26 => {
                    self.cache_location = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.max_size_gb = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.p2p_enabled = ::std::option::Option::Some(is.read_bool()?);
                },
                74 => {
                    self.explicit_ip_address = ::std::option::Option::Some(is.read_string()?);
                },
                80 => {
                    self.external_process = ::std::option::Option::Some(is.read_bool()?);
                },
                48 => {
                    self.current_size_gb = ::std::option::Option::Some(is.read_uint32()?);
                },
                56 => {
                    self.current_bw = ::std::option::Option::Some(is.read_uint64()?);
                },
                64 => {
                    self.total_bytes_served = ::std::option::Option::Some(is.read_uint64()?);
                },
                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;
        }
        if let Some(v) = self.port {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.cache_location.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.max_size_gb {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.p2p_enabled {
            my_size += 1 + 1;
        }
        if let Some(v) = self.explicit_ip_address.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &v);
        }
        if let Some(v) = self.external_process {
            my_size += 1 + 1;
        }
        if let Some(v) = self.current_size_gb {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.current_bw {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(7, v);
        }
        if let Some(v) = self.total_bytes_served {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(8, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.enabled {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.port {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.cache_location.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.max_size_gb {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.p2p_enabled {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.explicit_ip_address.as_ref() {
            os.write_string(9, v)?;
        }
        if let Some(v) = self.external_process {
            os.write_bool(10, v)?;
        }
        if let Some(v) = self.current_size_gb {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.current_bw {
            os.write_uint64(7, v)?;
        }
        if let Some(v) = self.total_bytes_served {
            os.write_uint64(8, 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() -> SiteServerUI_ContentCacheStatus_Response {
        SiteServerUI_ContentCacheStatus_Response::new()
    }

    fn clear(&mut self) {
        self.enabled = ::std::option::Option::None;
        self.port = ::std::option::Option::None;
        self.cache_location = ::std::option::Option::None;
        self.max_size_gb = ::std::option::Option::None;
        self.p2p_enabled = ::std::option::Option::None;
        self.explicit_ip_address = ::std::option::Option::None;
        self.external_process = ::std::option::Option::None;
        self.current_size_gb = ::std::option::Option::None;
        self.current_bw = ::std::option::Option::None;
        self.total_bytes_served = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static SiteServerUI_ContentCacheStatus_Response {
        static instance: SiteServerUI_ContentCacheStatus_Response = SiteServerUI_ContentCacheStatus_Response {
            enabled: ::std::option::Option::None,
            port: ::std::option::Option::None,
            cache_location: ::std::option::Option::None,
            max_size_gb: ::std::option::Option::None,
            p2p_enabled: ::std::option::Option::None,
            explicit_ip_address: ::std::option::Option::None,
            external_process: ::std::option::Option::None,
            current_size_gb: ::std::option::Option::None,
            current_bw: ::std::option::Option::None,
            total_bytes_served: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:SiteServerUI_ContentCacheConfig_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SiteServerUI_ContentCacheConfig_Request {
    // message fields
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheConfig_Request.enabled)
    pub enabled: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheConfig_Request.port)
    pub port: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheConfig_Request.cache_location)
    pub cache_location: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheConfig_Request.max_size_gb)
    pub max_size_gb: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheConfig_Request.p2p_enabled)
    pub p2p_enabled: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheConfig_Request.external_process)
    pub external_process: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:SiteServerUI_ContentCacheConfig_Request.explicit_ip_address)
    pub explicit_ip_address: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:SiteServerUI_ContentCacheConfig_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl SiteServerUI_ContentCacheConfig_Request {
    pub fn new() -> SiteServerUI_ContentCacheConfig_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);
    }

    // optional uint32 port = 2;

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

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

    pub fn has_port(&self) -> bool {
        self.port.is_some()
    }

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

    // optional string cache_location = 3;

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

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

    pub fn has_cache_location(&self) -> bool {
        self.cache_location.is_some()
    }

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

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

    // optional uint32 max_size_gb = 4;

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

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

    pub fn has_max_size_gb(&self) -> bool {
        self.max_size_gb.is_some()
    }

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

    // optional bool p2p_enabled = 5;

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

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

    pub fn has_p2p_enabled(&self) -> bool {
        self.p2p_enabled.is_some()
    }

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

    // optional bool external_process = 6;

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

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

    pub fn has_external_process(&self) -> bool {
        self.external_process.is_some()
    }

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

    // optional string explicit_ip_address = 7;

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

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

    pub fn has_explicit_ip_address(&self) -> bool {
        self.explicit_ip_address.is_some()
    }

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

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_ContentCacheConfig_Request {
    const NAME: &'static str = "SiteServerUI_ContentCacheConfig_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()?);
                },
                16 => {
                    self.port = ::std::option::Option::Some(is.read_uint32()?);
                },
                26 => {
                    self.cache_location = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.max_size_gb = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.p2p_enabled = ::std::option::Option::Some(is.read_bool()?);
                },
                48 => {
                    self.external_process = ::std::option::Option::Some(is.read_bool()?);
                },
                58 => {
                    self.explicit_ip_address = ::std::option::Option::Some(is.read_string()?);
                },
                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;
        }
        if let Some(v) = self.port {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.cache_location.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.max_size_gb {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.p2p_enabled {
            my_size += 1 + 1;
        }
        if let Some(v) = self.external_process {
            my_size += 1 + 1;
        }
        if let Some(v) = self.explicit_ip_address.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.enabled {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.port {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.cache_location.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.max_size_gb {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.p2p_enabled {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.external_process {
            os.write_bool(6, v)?;
        }
        if let Some(v) = self.explicit_ip_address.as_ref() {
            os.write_string(7, 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() -> SiteServerUI_ContentCacheConfig_Request {
        SiteServerUI_ContentCacheConfig_Request::new()
    }

    fn clear(&mut self) {
        self.enabled = ::std::option::Option::None;
        self.port = ::std::option::Option::None;
        self.cache_location = ::std::option::Option::None;
        self.max_size_gb = ::std::option::Option::None;
        self.p2p_enabled = ::std::option::Option::None;
        self.external_process = ::std::option::Option::None;
        self.explicit_ip_address = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static SiteServerUI_ContentCacheConfig_Request {
        static instance: SiteServerUI_ContentCacheConfig_Request = SiteServerUI_ContentCacheConfig_Request {
            enabled: ::std::option::Option::None,
            port: ::std::option::Option::None,
            cache_location: ::std::option::Option::None,
            max_size_gb: ::std::option::Option::None,
            p2p_enabled: ::std::option::Option::None,
            external_process: ::std::option::Option::None,
            explicit_ip_address: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_ContentCacheConfig_Response {
    const NAME: &'static str = "SiteServerUI_ContentCacheConfig_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() -> SiteServerUI_ContentCacheConfig_Response {
        SiteServerUI_ContentCacheConfig_Response::new()
    }

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

    fn default_instance() -> &'static SiteServerUI_ContentCacheConfig_Response {
        static instance: SiteServerUI_ContentCacheConfig_Response = SiteServerUI_ContentCacheConfig_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::steammessages_base::*;
impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_Login_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 SiteServerUI_Login_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 SiteServerUI_LoginStatus_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 SiteServerUI_LoginStatus_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 SiteServerUI_CancelLogin_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 SiteServerUI_CancelLogin_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 SiteServerUI_Logout_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 SiteServerUI_Logout_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 SiteServerUI_Quit_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 SiteServerUI_Quit_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 SiteServerUI_Status_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 SiteServerUI_Status_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 SiteServerUI_GetLanguage_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 SiteServerUI_GetLanguage_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 SiteServerUI_SetLanguage_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 SiteServerUI_SetLanguage_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 SiteServerUI_ClientStatus_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 SiteServerUI_ClientStatus_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 SiteServerUI_ContentCacheStatus_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 SiteServerUI_ContentCacheStatus_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 SiteServerUI_ContentCacheConfig_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 SiteServerUI_ContentCacheConfig_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
    }
}
