// 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_clientserver_login.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:CMsgClientHeartBeat)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgClientHeartBeat {
    // message fields
    // @@protoc_insertion_point(field:CMsgClientHeartBeat.send_reply)
    pub send_reply: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgClientHeartBeat.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional bool send_reply = 1;

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

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

    pub fn has_send_reply(&self) -> bool {
        self.send_reply.is_some()
    }

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

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

    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.send_reply = ::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.send_reply {
            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.send_reply {
            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() -> CMsgClientHeartBeat {
        CMsgClientHeartBeat::new()
    }

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

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

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

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

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

    // optional uint64 client_request_timestamp = 1;

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

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

    pub fn has_client_request_timestamp(&self) -> bool {
        self.client_request_timestamp.is_some()
    }

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

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

    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.client_request_timestamp = ::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.client_request_timestamp {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.client_request_timestamp {
            os.write_uint64(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() -> CMsgClientServerTimestampRequest {
        CMsgClientServerTimestampRequest::new()
    }

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

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

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

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

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

    // optional uint64 client_request_timestamp = 1;

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

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

    pub fn has_client_request_timestamp(&self) -> bool {
        self.client_request_timestamp.is_some()
    }

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

    // optional uint64 server_timestamp_ms = 2;

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

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

    pub fn has_server_timestamp_ms(&self) -> bool {
        self.server_timestamp_ms.is_some()
    }

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

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

    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.client_request_timestamp = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.server_timestamp_ms = ::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.client_request_timestamp {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.server_timestamp_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.client_request_timestamp {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.server_timestamp_ms {
            os.write_uint64(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() -> CMsgClientServerTimestampResponse {
        CMsgClientServerTimestampResponse::new()
    }

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

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

// @@protoc_insertion_point(message:CMsgClientSecret)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgClientSecret {
    // message fields
    // @@protoc_insertion_point(field:CMsgClientSecret.version)
    pub version: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientSecret.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientSecret.deviceid)
    pub deviceid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientSecret.nonce)
    pub nonce: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgClientSecret.hmac)
    pub hmac: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgClientSecret.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 version = 1;

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

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

    pub fn has_version(&self) -> bool {
        self.version.is_some()
    }

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

    // optional uint32 appid = 2;

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

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

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

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

    // optional uint32 deviceid = 3;

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

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

    pub fn has_deviceid(&self) -> bool {
        self.deviceid.is_some()
    }

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

    // optional fixed64 nonce = 4;

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

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

    pub fn has_nonce(&self) -> bool {
        self.nonce.is_some()
    }

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

    // optional bytes hmac = 5;

    pub fn hmac(&self) -> &[u8] {
        match self.hmac.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

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

    pub fn has_hmac(&self) -> bool {
        self.hmac.is_some()
    }

    // Param is passed by value, moved
    pub fn set_hmac(&mut self, v: ::std::vec::Vec<u8>) {
        self.hmac = ::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_hmac(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.hmac.is_none() {
            self.hmac = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.hmac.as_mut().unwrap()
    }

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

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

    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.version = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.deviceid = ::std::option::Option::Some(is.read_uint32()?);
                },
                33 => {
                    self.nonce = ::std::option::Option::Some(is.read_fixed64()?);
                },
                42 => {
                    self.hmac = ::std::option::Option::Some(is.read_bytes()?);
                },
                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.version {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.deviceid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.nonce {
            my_size += 1 + 8;
        }
        if let Some(v) = self.hmac.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_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.version {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.deviceid {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.nonce {
            os.write_fixed64(4, v)?;
        }
        if let Some(v) = self.hmac.as_ref() {
            os.write_bytes(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() -> CMsgClientSecret {
        CMsgClientSecret::new()
    }

    fn clear(&mut self) {
        self.version = ::std::option::Option::None;
        self.appid = ::std::option::Option::None;
        self.deviceid = ::std::option::Option::None;
        self.nonce = ::std::option::Option::None;
        self.hmac = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgClientSecret {
        static instance: CMsgClientSecret = CMsgClientSecret {
            version: ::std::option::Option::None,
            appid: ::std::option::Option::None,
            deviceid: ::std::option::Option::None,
            nonce: ::std::option::Option::None,
            hmac: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional uint32 protocol_version = 1;

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

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

    pub fn has_protocol_version(&self) -> bool {
        self.protocol_version.is_some()
    }

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

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

    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.protocol_version = ::std::option::Option::Some(is.read_uint32()?);
                },
                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.protocol_version {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_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.protocol_version {
            os.write_uint32(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() -> CMsgClientHello {
        CMsgClientHello::new()
    }

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

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

// @@protoc_insertion_point(message:CMsgClientLogon)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgClientLogon {
    // message fields
    // @@protoc_insertion_point(field:CMsgClientLogon.protocol_version)
    pub protocol_version: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.deprecated_obfustucated_private_ip)
    pub deprecated_obfustucated_private_ip: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.cell_id)
    pub cell_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.last_session_id)
    pub last_session_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.client_package_version)
    pub client_package_version: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.client_language)
    pub client_language: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.client_os_type)
    pub client_os_type: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.should_remember_password)
    pub should_remember_password: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgClientLogon.wine_version)
    pub wine_version: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.deprecated_10)
    pub deprecated_10: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.obfuscated_private_ip)
    pub obfuscated_private_ip: ::steam_vent_proto_common::protobuf::MessageField<super::steammessages_base::CMsgIPAddress>,
    // @@protoc_insertion_point(field:CMsgClientLogon.deprecated_public_ip)
    pub deprecated_public_ip: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.qos_level)
    pub qos_level: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.client_supplied_steam_id)
    pub client_supplied_steam_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgClientLogon.public_ip)
    pub public_ip: ::steam_vent_proto_common::protobuf::MessageField<super::steammessages_base::CMsgIPAddress>,
    // @@protoc_insertion_point(field:CMsgClientLogon.machine_id)
    pub machine_id: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgClientLogon.launcher_type)
    pub launcher_type: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.ui_mode)
    pub ui_mode: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.chat_mode)
    pub chat_mode: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.steam2_auth_ticket)
    pub steam2_auth_ticket: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgClientLogon.email_address)
    pub email_address: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.rtime32_account_creation)
    pub rtime32_account_creation: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.account_name)
    pub account_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.password)
    pub password: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.game_server_token)
    pub game_server_token: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.login_key)
    pub login_key: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.was_converted_deprecated_msg)
    pub was_converted_deprecated_msg: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgClientLogon.anon_user_target_account_name)
    pub anon_user_target_account_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.resolved_user_steam_id)
    pub resolved_user_steam_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgClientLogon.eresult_sentryfile)
    pub eresult_sentryfile: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.sha_sentryfile)
    pub sha_sentryfile: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgClientLogon.auth_code)
    pub auth_code: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.otp_type)
    pub otp_type: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.otp_value)
    pub otp_value: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.otp_identifier)
    pub otp_identifier: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.steam2_ticket_request)
    pub steam2_ticket_request: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgClientLogon.sony_psn_ticket)
    pub sony_psn_ticket: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgClientLogon.sony_psn_service_id)
    pub sony_psn_service_id: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.create_new_psn_linked_account_if_needed)
    pub create_new_psn_linked_account_if_needed: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgClientLogon.sony_psn_name)
    pub sony_psn_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.game_server_app_id)
    pub game_server_app_id: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.steamguard_dont_remember_computer)
    pub steamguard_dont_remember_computer: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgClientLogon.machine_name)
    pub machine_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.machine_name_userchosen)
    pub machine_name_userchosen: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.country_override)
    pub country_override: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.client_instance_id)
    pub client_instance_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgClientLogon.two_factor_code)
    pub two_factor_code: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.supports_rate_limit_response)
    pub supports_rate_limit_response: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgClientLogon.web_logon_nonce)
    pub web_logon_nonce: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.priority_reason)
    pub priority_reason: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgClientLogon.embedded_client_secret)
    pub embedded_client_secret: ::steam_vent_proto_common::protobuf::MessageField<CMsgClientSecret>,
    // @@protoc_insertion_point(field:CMsgClientLogon.disable_partner_autogrants)
    pub disable_partner_autogrants: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgClientLogon.access_token)
    pub access_token: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogon.is_chrome_os)
    pub is_chrome_os: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgClientLogon.is_steam_box_deprecated)
    pub is_steam_box_deprecated: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgClientLogon.is_steam_deck_deprecated)
    pub is_steam_deck_deprecated: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgClientLogon.is_tesla_deprecated)
    pub is_tesla_deprecated: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgClientLogon.gaming_device_type)
    pub gaming_device_type: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgClientLogon.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 protocol_version = 1;

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

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

    pub fn has_protocol_version(&self) -> bool {
        self.protocol_version.is_some()
    }

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

    // optional uint32 deprecated_obfustucated_private_ip = 2;

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

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

    pub fn has_deprecated_obfustucated_private_ip(&self) -> bool {
        self.deprecated_obfustucated_private_ip.is_some()
    }

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

    // optional uint32 cell_id = 3;

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

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

    pub fn has_cell_id(&self) -> bool {
        self.cell_id.is_some()
    }

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

    // optional uint32 last_session_id = 4;

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

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

    pub fn has_last_session_id(&self) -> bool {
        self.last_session_id.is_some()
    }

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

    // optional uint32 client_package_version = 5;

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

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

    pub fn has_client_package_version(&self) -> bool {
        self.client_package_version.is_some()
    }

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

    // optional string client_language = 6;

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

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

    pub fn has_client_language(&self) -> bool {
        self.client_language.is_some()
    }

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

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

    // optional uint32 client_os_type = 7;

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

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

    pub fn has_client_os_type(&self) -> bool {
        self.client_os_type.is_some()
    }

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

    // optional bool should_remember_password = 8;

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

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

    pub fn has_should_remember_password(&self) -> bool {
        self.should_remember_password.is_some()
    }

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

    // optional string wine_version = 9;

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

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

    pub fn has_wine_version(&self) -> bool {
        self.wine_version.is_some()
    }

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

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

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

    // optional uint32 deprecated_10 = 10;

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

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

    pub fn has_deprecated_10(&self) -> bool {
        self.deprecated_10.is_some()
    }

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

    // optional uint32 deprecated_public_ip = 20;

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

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

    pub fn has_deprecated_public_ip(&self) -> bool {
        self.deprecated_public_ip.is_some()
    }

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

    // optional uint32 qos_level = 21;

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

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

    pub fn has_qos_level(&self) -> bool {
        self.qos_level.is_some()
    }

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

    // optional fixed64 client_supplied_steam_id = 22;

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

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

    pub fn has_client_supplied_steam_id(&self) -> bool {
        self.client_supplied_steam_id.is_some()
    }

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

    // optional bytes machine_id = 30;

    pub fn machine_id(&self) -> &[u8] {
        match self.machine_id.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

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

    pub fn has_machine_id(&self) -> bool {
        self.machine_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_machine_id(&mut self, v: ::std::vec::Vec<u8>) {
        self.machine_id = ::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_machine_id(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.machine_id.is_none() {
            self.machine_id = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.machine_id.as_mut().unwrap()
    }

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

    // optional uint32 launcher_type = 31;

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

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

    pub fn has_launcher_type(&self) -> bool {
        self.launcher_type.is_some()
    }

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

    // optional uint32 ui_mode = 32;

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

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

    pub fn has_ui_mode(&self) -> bool {
        self.ui_mode.is_some()
    }

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

    // optional uint32 chat_mode = 33;

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

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

    pub fn has_chat_mode(&self) -> bool {
        self.chat_mode.is_some()
    }

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

    // optional bytes steam2_auth_ticket = 41;

    pub fn steam2_auth_ticket(&self) -> &[u8] {
        match self.steam2_auth_ticket.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

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

    pub fn has_steam2_auth_ticket(&self) -> bool {
        self.steam2_auth_ticket.is_some()
    }

    // Param is passed by value, moved
    pub fn set_steam2_auth_ticket(&mut self, v: ::std::vec::Vec<u8>) {
        self.steam2_auth_ticket = ::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_steam2_auth_ticket(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.steam2_auth_ticket.is_none() {
            self.steam2_auth_ticket = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.steam2_auth_ticket.as_mut().unwrap()
    }

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

    // optional string email_address = 42;

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

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

    pub fn has_email_address(&self) -> bool {
        self.email_address.is_some()
    }

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

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

    // optional fixed32 rtime32_account_creation = 43;

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

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

    pub fn has_rtime32_account_creation(&self) -> bool {
        self.rtime32_account_creation.is_some()
    }

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

    // optional string account_name = 50;

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

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

    pub fn has_account_name(&self) -> bool {
        self.account_name.is_some()
    }

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

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

    // optional string password = 51;

    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 game_server_token = 52;

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

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

    pub fn has_game_server_token(&self) -> bool {
        self.game_server_token.is_some()
    }

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

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

    // optional string login_key = 60;

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

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

    pub fn has_login_key(&self) -> bool {
        self.login_key.is_some()
    }

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

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

    // optional bool was_converted_deprecated_msg = 70;

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

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

    pub fn has_was_converted_deprecated_msg(&self) -> bool {
        self.was_converted_deprecated_msg.is_some()
    }

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

    // optional string anon_user_target_account_name = 80;

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

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

    pub fn has_anon_user_target_account_name(&self) -> bool {
        self.anon_user_target_account_name.is_some()
    }

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

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

    // optional fixed64 resolved_user_steam_id = 81;

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

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

    pub fn has_resolved_user_steam_id(&self) -> bool {
        self.resolved_user_steam_id.is_some()
    }

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

    // optional int32 eresult_sentryfile = 82;

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

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

    pub fn has_eresult_sentryfile(&self) -> bool {
        self.eresult_sentryfile.is_some()
    }

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

    // optional bytes sha_sentryfile = 83;

    pub fn sha_sentryfile(&self) -> &[u8] {
        match self.sha_sentryfile.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

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

    pub fn has_sha_sentryfile(&self) -> bool {
        self.sha_sentryfile.is_some()
    }

    // Param is passed by value, moved
    pub fn set_sha_sentryfile(&mut self, v: ::std::vec::Vec<u8>) {
        self.sha_sentryfile = ::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_sha_sentryfile(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.sha_sentryfile.is_none() {
            self.sha_sentryfile = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.sha_sentryfile.as_mut().unwrap()
    }

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

    // optional string auth_code = 84;

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

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

    pub fn has_auth_code(&self) -> bool {
        self.auth_code.is_some()
    }

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

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

    // optional int32 otp_type = 85;

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

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

    pub fn has_otp_type(&self) -> bool {
        self.otp_type.is_some()
    }

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

    // optional uint32 otp_value = 86;

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

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

    pub fn has_otp_value(&self) -> bool {
        self.otp_value.is_some()
    }

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

    // optional string otp_identifier = 87;

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

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

    pub fn has_otp_identifier(&self) -> bool {
        self.otp_identifier.is_some()
    }

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

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

    // optional bool steam2_ticket_request = 88;

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

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

    pub fn has_steam2_ticket_request(&self) -> bool {
        self.steam2_ticket_request.is_some()
    }

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

    // optional bytes sony_psn_ticket = 90;

    pub fn sony_psn_ticket(&self) -> &[u8] {
        match self.sony_psn_ticket.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

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

    pub fn has_sony_psn_ticket(&self) -> bool {
        self.sony_psn_ticket.is_some()
    }

    // Param is passed by value, moved
    pub fn set_sony_psn_ticket(&mut self, v: ::std::vec::Vec<u8>) {
        self.sony_psn_ticket = ::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_sony_psn_ticket(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.sony_psn_ticket.is_none() {
            self.sony_psn_ticket = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.sony_psn_ticket.as_mut().unwrap()
    }

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

    // optional string sony_psn_service_id = 91;

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

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

    pub fn has_sony_psn_service_id(&self) -> bool {
        self.sony_psn_service_id.is_some()
    }

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

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

    // optional bool create_new_psn_linked_account_if_needed = 92;

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

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

    pub fn has_create_new_psn_linked_account_if_needed(&self) -> bool {
        self.create_new_psn_linked_account_if_needed.is_some()
    }

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

    // optional string sony_psn_name = 93;

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

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

    pub fn has_sony_psn_name(&self) -> bool {
        self.sony_psn_name.is_some()
    }

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

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

    // optional int32 game_server_app_id = 94;

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

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

    pub fn has_game_server_app_id(&self) -> bool {
        self.game_server_app_id.is_some()
    }

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

    // optional bool steamguard_dont_remember_computer = 95;

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

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

    pub fn has_steamguard_dont_remember_computer(&self) -> bool {
        self.steamguard_dont_remember_computer.is_some()
    }

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

    // optional string machine_name = 96;

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

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

    pub fn has_machine_name(&self) -> bool {
        self.machine_name.is_some()
    }

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

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

    // optional string machine_name_userchosen = 97;

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

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

    pub fn has_machine_name_userchosen(&self) -> bool {
        self.machine_name_userchosen.is_some()
    }

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

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

    // optional string country_override = 98;

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

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

    pub fn has_country_override(&self) -> bool {
        self.country_override.is_some()
    }

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

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

    // optional uint64 client_instance_id = 100;

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

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

    pub fn has_client_instance_id(&self) -> bool {
        self.client_instance_id.is_some()
    }

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

    // optional string two_factor_code = 101;

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

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

    pub fn has_two_factor_code(&self) -> bool {
        self.two_factor_code.is_some()
    }

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

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

    // optional bool supports_rate_limit_response = 102;

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

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

    pub fn has_supports_rate_limit_response(&self) -> bool {
        self.supports_rate_limit_response.is_some()
    }

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

    // optional string web_logon_nonce = 103;

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

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

    pub fn has_web_logon_nonce(&self) -> bool {
        self.web_logon_nonce.is_some()
    }

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

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

    // optional int32 priority_reason = 104;

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

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

    pub fn has_priority_reason(&self) -> bool {
        self.priority_reason.is_some()
    }

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

    // optional bool disable_partner_autogrants = 106;

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

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

    pub fn has_disable_partner_autogrants(&self) -> bool {
        self.disable_partner_autogrants.is_some()
    }

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

    // optional string access_token = 108;

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

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

    pub fn has_access_token(&self) -> bool {
        self.access_token.is_some()
    }

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

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

    // optional bool is_chrome_os = 109;

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

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

    pub fn has_is_chrome_os(&self) -> bool {
        self.is_chrome_os.is_some()
    }

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

    // optional bool is_steam_box_deprecated = 99;

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

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

    pub fn has_is_steam_box_deprecated(&self) -> bool {
        self.is_steam_box_deprecated.is_some()
    }

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

    // optional bool is_steam_deck_deprecated = 107;

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

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

    pub fn has_is_steam_deck_deprecated(&self) -> bool {
        self.is_steam_deck_deprecated.is_some()
    }

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

    // optional bool is_tesla_deprecated = 110;

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

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

    pub fn has_is_tesla_deprecated(&self) -> bool {
        self.is_tesla_deprecated.is_some()
    }

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

    // optional uint32 gaming_device_type = 111;

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

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

    pub fn has_gaming_device_type(&self) -> bool {
        self.gaming_device_type.is_some()
    }

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

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

    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.protocol_version = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.deprecated_obfustucated_private_ip = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.cell_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.last_session_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.client_package_version = ::std::option::Option::Some(is.read_uint32()?);
                },
                50 => {
                    self.client_language = ::std::option::Option::Some(is.read_string()?);
                },
                56 => {
                    self.client_os_type = ::std::option::Option::Some(is.read_uint32()?);
                },
                64 => {
                    self.should_remember_password = ::std::option::Option::Some(is.read_bool()?);
                },
                74 => {
                    self.wine_version = ::std::option::Option::Some(is.read_string()?);
                },
                80 => {
                    self.deprecated_10 = ::std::option::Option::Some(is.read_uint32()?);
                },
                90 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.obfuscated_private_ip)?;
                },
                160 => {
                    self.deprecated_public_ip = ::std::option::Option::Some(is.read_uint32()?);
                },
                168 => {
                    self.qos_level = ::std::option::Option::Some(is.read_uint32()?);
                },
                177 => {
                    self.client_supplied_steam_id = ::std::option::Option::Some(is.read_fixed64()?);
                },
                186 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.public_ip)?;
                },
                242 => {
                    self.machine_id = ::std::option::Option::Some(is.read_bytes()?);
                },
                248 => {
                    self.launcher_type = ::std::option::Option::Some(is.read_uint32()?);
                },
                256 => {
                    self.ui_mode = ::std::option::Option::Some(is.read_uint32()?);
                },
                264 => {
                    self.chat_mode = ::std::option::Option::Some(is.read_uint32()?);
                },
                330 => {
                    self.steam2_auth_ticket = ::std::option::Option::Some(is.read_bytes()?);
                },
                338 => {
                    self.email_address = ::std::option::Option::Some(is.read_string()?);
                },
                349 => {
                    self.rtime32_account_creation = ::std::option::Option::Some(is.read_fixed32()?);
                },
                402 => {
                    self.account_name = ::std::option::Option::Some(is.read_string()?);
                },
                410 => {
                    self.password = ::std::option::Option::Some(is.read_string()?);
                },
                418 => {
                    self.game_server_token = ::std::option::Option::Some(is.read_string()?);
                },
                482 => {
                    self.login_key = ::std::option::Option::Some(is.read_string()?);
                },
                560 => {
                    self.was_converted_deprecated_msg = ::std::option::Option::Some(is.read_bool()?);
                },
                642 => {
                    self.anon_user_target_account_name = ::std::option::Option::Some(is.read_string()?);
                },
                649 => {
                    self.resolved_user_steam_id = ::std::option::Option::Some(is.read_fixed64()?);
                },
                656 => {
                    self.eresult_sentryfile = ::std::option::Option::Some(is.read_int32()?);
                },
                666 => {
                    self.sha_sentryfile = ::std::option::Option::Some(is.read_bytes()?);
                },
                674 => {
                    self.auth_code = ::std::option::Option::Some(is.read_string()?);
                },
                680 => {
                    self.otp_type = ::std::option::Option::Some(is.read_int32()?);
                },
                688 => {
                    self.otp_value = ::std::option::Option::Some(is.read_uint32()?);
                },
                698 => {
                    self.otp_identifier = ::std::option::Option::Some(is.read_string()?);
                },
                704 => {
                    self.steam2_ticket_request = ::std::option::Option::Some(is.read_bool()?);
                },
                722 => {
                    self.sony_psn_ticket = ::std::option::Option::Some(is.read_bytes()?);
                },
                730 => {
                    self.sony_psn_service_id = ::std::option::Option::Some(is.read_string()?);
                },
                736 => {
                    self.create_new_psn_linked_account_if_needed = ::std::option::Option::Some(is.read_bool()?);
                },
                746 => {
                    self.sony_psn_name = ::std::option::Option::Some(is.read_string()?);
                },
                752 => {
                    self.game_server_app_id = ::std::option::Option::Some(is.read_int32()?);
                },
                760 => {
                    self.steamguard_dont_remember_computer = ::std::option::Option::Some(is.read_bool()?);
                },
                770 => {
                    self.machine_name = ::std::option::Option::Some(is.read_string()?);
                },
                778 => {
                    self.machine_name_userchosen = ::std::option::Option::Some(is.read_string()?);
                },
                786 => {
                    self.country_override = ::std::option::Option::Some(is.read_string()?);
                },
                800 => {
                    self.client_instance_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                810 => {
                    self.two_factor_code = ::std::option::Option::Some(is.read_string()?);
                },
                816 => {
                    self.supports_rate_limit_response = ::std::option::Option::Some(is.read_bool()?);
                },
                826 => {
                    self.web_logon_nonce = ::std::option::Option::Some(is.read_string()?);
                },
                832 => {
                    self.priority_reason = ::std::option::Option::Some(is.read_int32()?);
                },
                842 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.embedded_client_secret)?;
                },
                848 => {
                    self.disable_partner_autogrants = ::std::option::Option::Some(is.read_bool()?);
                },
                866 => {
                    self.access_token = ::std::option::Option::Some(is.read_string()?);
                },
                872 => {
                    self.is_chrome_os = ::std::option::Option::Some(is.read_bool()?);
                },
                792 => {
                    self.is_steam_box_deprecated = ::std::option::Option::Some(is.read_bool()?);
                },
                856 => {
                    self.is_steam_deck_deprecated = ::std::option::Option::Some(is.read_bool()?);
                },
                880 => {
                    self.is_tesla_deprecated = ::std::option::Option::Some(is.read_bool()?);
                },
                888 => {
                    self.gaming_device_type = ::std::option::Option::Some(is.read_uint32()?);
                },
                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.protocol_version {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.deprecated_obfustucated_private_ip {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.cell_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.last_session_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.client_package_version {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.client_language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.client_os_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.should_remember_password {
            my_size += 1 + 1;
        }
        if let Some(v) = self.wine_version.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &v);
        }
        if let Some(v) = self.deprecated_10 {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(10, v);
        }
        if let Some(v) = self.obfuscated_private_ip.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.deprecated_public_ip {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(20, v);
        }
        if let Some(v) = self.qos_level {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(21, v);
        }
        if let Some(v) = self.client_supplied_steam_id {
            my_size += 2 + 8;
        }
        if let Some(v) = self.public_ip.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.machine_id.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(30, &v);
        }
        if let Some(v) = self.launcher_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(31, v);
        }
        if let Some(v) = self.ui_mode {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(32, v);
        }
        if let Some(v) = self.chat_mode {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(33, v);
        }
        if let Some(v) = self.steam2_auth_ticket.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(41, &v);
        }
        if let Some(v) = self.email_address.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(42, &v);
        }
        if let Some(v) = self.rtime32_account_creation {
            my_size += 2 + 4;
        }
        if let Some(v) = self.account_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(50, &v);
        }
        if let Some(v) = self.password.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(51, &v);
        }
        if let Some(v) = self.game_server_token.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(52, &v);
        }
        if let Some(v) = self.login_key.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(60, &v);
        }
        if let Some(v) = self.was_converted_deprecated_msg {
            my_size += 2 + 1;
        }
        if let Some(v) = self.anon_user_target_account_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(80, &v);
        }
        if let Some(v) = self.resolved_user_steam_id {
            my_size += 2 + 8;
        }
        if let Some(v) = self.eresult_sentryfile {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(82, v);
        }
        if let Some(v) = self.sha_sentryfile.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(83, &v);
        }
        if let Some(v) = self.auth_code.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(84, &v);
        }
        if let Some(v) = self.otp_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(85, v);
        }
        if let Some(v) = self.otp_value {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(86, v);
        }
        if let Some(v) = self.otp_identifier.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(87, &v);
        }
        if let Some(v) = self.steam2_ticket_request {
            my_size += 2 + 1;
        }
        if let Some(v) = self.sony_psn_ticket.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(90, &v);
        }
        if let Some(v) = self.sony_psn_service_id.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(91, &v);
        }
        if let Some(v) = self.create_new_psn_linked_account_if_needed {
            my_size += 2 + 1;
        }
        if let Some(v) = self.sony_psn_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(93, &v);
        }
        if let Some(v) = self.game_server_app_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(94, v);
        }
        if let Some(v) = self.steamguard_dont_remember_computer {
            my_size += 2 + 1;
        }
        if let Some(v) = self.machine_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(96, &v);
        }
        if let Some(v) = self.machine_name_userchosen.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(97, &v);
        }
        if let Some(v) = self.country_override.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(98, &v);
        }
        if let Some(v) = self.client_instance_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(100, v);
        }
        if let Some(v) = self.two_factor_code.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(101, &v);
        }
        if let Some(v) = self.supports_rate_limit_response {
            my_size += 2 + 1;
        }
        if let Some(v) = self.web_logon_nonce.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(103, &v);
        }
        if let Some(v) = self.priority_reason {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(104, v);
        }
        if let Some(v) = self.embedded_client_secret.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.disable_partner_autogrants {
            my_size += 2 + 1;
        }
        if let Some(v) = self.access_token.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(108, &v);
        }
        if let Some(v) = self.is_chrome_os {
            my_size += 2 + 1;
        }
        if let Some(v) = self.is_steam_box_deprecated {
            my_size += 2 + 1;
        }
        if let Some(v) = self.is_steam_deck_deprecated {
            my_size += 2 + 1;
        }
        if let Some(v) = self.is_tesla_deprecated {
            my_size += 2 + 1;
        }
        if let Some(v) = self.gaming_device_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(111, 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.protocol_version {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.deprecated_obfustucated_private_ip {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.cell_id {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.last_session_id {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.client_package_version {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.client_language.as_ref() {
            os.write_string(6, v)?;
        }
        if let Some(v) = self.client_os_type {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.should_remember_password {
            os.write_bool(8, v)?;
        }
        if let Some(v) = self.wine_version.as_ref() {
            os.write_string(9, v)?;
        }
        if let Some(v) = self.deprecated_10 {
            os.write_uint32(10, v)?;
        }
        if let Some(v) = self.obfuscated_private_ip.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(11, v, os)?;
        }
        if let Some(v) = self.deprecated_public_ip {
            os.write_uint32(20, v)?;
        }
        if let Some(v) = self.qos_level {
            os.write_uint32(21, v)?;
        }
        if let Some(v) = self.client_supplied_steam_id {
            os.write_fixed64(22, v)?;
        }
        if let Some(v) = self.public_ip.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(23, v, os)?;
        }
        if let Some(v) = self.machine_id.as_ref() {
            os.write_bytes(30, v)?;
        }
        if let Some(v) = self.launcher_type {
            os.write_uint32(31, v)?;
        }
        if let Some(v) = self.ui_mode {
            os.write_uint32(32, v)?;
        }
        if let Some(v) = self.chat_mode {
            os.write_uint32(33, v)?;
        }
        if let Some(v) = self.steam2_auth_ticket.as_ref() {
            os.write_bytes(41, v)?;
        }
        if let Some(v) = self.email_address.as_ref() {
            os.write_string(42, v)?;
        }
        if let Some(v) = self.rtime32_account_creation {
            os.write_fixed32(43, v)?;
        }
        if let Some(v) = self.account_name.as_ref() {
            os.write_string(50, v)?;
        }
        if let Some(v) = self.password.as_ref() {
            os.write_string(51, v)?;
        }
        if let Some(v) = self.game_server_token.as_ref() {
            os.write_string(52, v)?;
        }
        if let Some(v) = self.login_key.as_ref() {
            os.write_string(60, v)?;
        }
        if let Some(v) = self.was_converted_deprecated_msg {
            os.write_bool(70, v)?;
        }
        if let Some(v) = self.anon_user_target_account_name.as_ref() {
            os.write_string(80, v)?;
        }
        if let Some(v) = self.resolved_user_steam_id {
            os.write_fixed64(81, v)?;
        }
        if let Some(v) = self.eresult_sentryfile {
            os.write_int32(82, v)?;
        }
        if let Some(v) = self.sha_sentryfile.as_ref() {
            os.write_bytes(83, v)?;
        }
        if let Some(v) = self.auth_code.as_ref() {
            os.write_string(84, v)?;
        }
        if let Some(v) = self.otp_type {
            os.write_int32(85, v)?;
        }
        if let Some(v) = self.otp_value {
            os.write_uint32(86, v)?;
        }
        if let Some(v) = self.otp_identifier.as_ref() {
            os.write_string(87, v)?;
        }
        if let Some(v) = self.steam2_ticket_request {
            os.write_bool(88, v)?;
        }
        if let Some(v) = self.sony_psn_ticket.as_ref() {
            os.write_bytes(90, v)?;
        }
        if let Some(v) = self.sony_psn_service_id.as_ref() {
            os.write_string(91, v)?;
        }
        if let Some(v) = self.create_new_psn_linked_account_if_needed {
            os.write_bool(92, v)?;
        }
        if let Some(v) = self.sony_psn_name.as_ref() {
            os.write_string(93, v)?;
        }
        if let Some(v) = self.game_server_app_id {
            os.write_int32(94, v)?;
        }
        if let Some(v) = self.steamguard_dont_remember_computer {
            os.write_bool(95, v)?;
        }
        if let Some(v) = self.machine_name.as_ref() {
            os.write_string(96, v)?;
        }
        if let Some(v) = self.machine_name_userchosen.as_ref() {
            os.write_string(97, v)?;
        }
        if let Some(v) = self.country_override.as_ref() {
            os.write_string(98, v)?;
        }
        if let Some(v) = self.client_instance_id {
            os.write_uint64(100, v)?;
        }
        if let Some(v) = self.two_factor_code.as_ref() {
            os.write_string(101, v)?;
        }
        if let Some(v) = self.supports_rate_limit_response {
            os.write_bool(102, v)?;
        }
        if let Some(v) = self.web_logon_nonce.as_ref() {
            os.write_string(103, v)?;
        }
        if let Some(v) = self.priority_reason {
            os.write_int32(104, v)?;
        }
        if let Some(v) = self.embedded_client_secret.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(105, v, os)?;
        }
        if let Some(v) = self.disable_partner_autogrants {
            os.write_bool(106, v)?;
        }
        if let Some(v) = self.access_token.as_ref() {
            os.write_string(108, v)?;
        }
        if let Some(v) = self.is_chrome_os {
            os.write_bool(109, v)?;
        }
        if let Some(v) = self.is_steam_box_deprecated {
            os.write_bool(99, v)?;
        }
        if let Some(v) = self.is_steam_deck_deprecated {
            os.write_bool(107, v)?;
        }
        if let Some(v) = self.is_tesla_deprecated {
            os.write_bool(110, v)?;
        }
        if let Some(v) = self.gaming_device_type {
            os.write_uint32(111, 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() -> CMsgClientLogon {
        CMsgClientLogon::new()
    }

    fn clear(&mut self) {
        self.protocol_version = ::std::option::Option::None;
        self.deprecated_obfustucated_private_ip = ::std::option::Option::None;
        self.cell_id = ::std::option::Option::None;
        self.last_session_id = ::std::option::Option::None;
        self.client_package_version = ::std::option::Option::None;
        self.client_language = ::std::option::Option::None;
        self.client_os_type = ::std::option::Option::None;
        self.should_remember_password = ::std::option::Option::None;
        self.wine_version = ::std::option::Option::None;
        self.deprecated_10 = ::std::option::Option::None;
        self.obfuscated_private_ip.clear();
        self.deprecated_public_ip = ::std::option::Option::None;
        self.qos_level = ::std::option::Option::None;
        self.client_supplied_steam_id = ::std::option::Option::None;
        self.public_ip.clear();
        self.machine_id = ::std::option::Option::None;
        self.launcher_type = ::std::option::Option::None;
        self.ui_mode = ::std::option::Option::None;
        self.chat_mode = ::std::option::Option::None;
        self.steam2_auth_ticket = ::std::option::Option::None;
        self.email_address = ::std::option::Option::None;
        self.rtime32_account_creation = ::std::option::Option::None;
        self.account_name = ::std::option::Option::None;
        self.password = ::std::option::Option::None;
        self.game_server_token = ::std::option::Option::None;
        self.login_key = ::std::option::Option::None;
        self.was_converted_deprecated_msg = ::std::option::Option::None;
        self.anon_user_target_account_name = ::std::option::Option::None;
        self.resolved_user_steam_id = ::std::option::Option::None;
        self.eresult_sentryfile = ::std::option::Option::None;
        self.sha_sentryfile = ::std::option::Option::None;
        self.auth_code = ::std::option::Option::None;
        self.otp_type = ::std::option::Option::None;
        self.otp_value = ::std::option::Option::None;
        self.otp_identifier = ::std::option::Option::None;
        self.steam2_ticket_request = ::std::option::Option::None;
        self.sony_psn_ticket = ::std::option::Option::None;
        self.sony_psn_service_id = ::std::option::Option::None;
        self.create_new_psn_linked_account_if_needed = ::std::option::Option::None;
        self.sony_psn_name = ::std::option::Option::None;
        self.game_server_app_id = ::std::option::Option::None;
        self.steamguard_dont_remember_computer = ::std::option::Option::None;
        self.machine_name = ::std::option::Option::None;
        self.machine_name_userchosen = ::std::option::Option::None;
        self.country_override = ::std::option::Option::None;
        self.client_instance_id = ::std::option::Option::None;
        self.two_factor_code = ::std::option::Option::None;
        self.supports_rate_limit_response = ::std::option::Option::None;
        self.web_logon_nonce = ::std::option::Option::None;
        self.priority_reason = ::std::option::Option::None;
        self.embedded_client_secret.clear();
        self.disable_partner_autogrants = ::std::option::Option::None;
        self.access_token = ::std::option::Option::None;
        self.is_chrome_os = ::std::option::Option::None;
        self.is_steam_box_deprecated = ::std::option::Option::None;
        self.is_steam_deck_deprecated = ::std::option::Option::None;
        self.is_tesla_deprecated = ::std::option::Option::None;
        self.gaming_device_type = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgClientLogon {
        static instance: CMsgClientLogon = CMsgClientLogon {
            protocol_version: ::std::option::Option::None,
            deprecated_obfustucated_private_ip: ::std::option::Option::None,
            cell_id: ::std::option::Option::None,
            last_session_id: ::std::option::Option::None,
            client_package_version: ::std::option::Option::None,
            client_language: ::std::option::Option::None,
            client_os_type: ::std::option::Option::None,
            should_remember_password: ::std::option::Option::None,
            wine_version: ::std::option::Option::None,
            deprecated_10: ::std::option::Option::None,
            obfuscated_private_ip: ::steam_vent_proto_common::protobuf::MessageField::none(),
            deprecated_public_ip: ::std::option::Option::None,
            qos_level: ::std::option::Option::None,
            client_supplied_steam_id: ::std::option::Option::None,
            public_ip: ::steam_vent_proto_common::protobuf::MessageField::none(),
            machine_id: ::std::option::Option::None,
            launcher_type: ::std::option::Option::None,
            ui_mode: ::std::option::Option::None,
            chat_mode: ::std::option::Option::None,
            steam2_auth_ticket: ::std::option::Option::None,
            email_address: ::std::option::Option::None,
            rtime32_account_creation: ::std::option::Option::None,
            account_name: ::std::option::Option::None,
            password: ::std::option::Option::None,
            game_server_token: ::std::option::Option::None,
            login_key: ::std::option::Option::None,
            was_converted_deprecated_msg: ::std::option::Option::None,
            anon_user_target_account_name: ::std::option::Option::None,
            resolved_user_steam_id: ::std::option::Option::None,
            eresult_sentryfile: ::std::option::Option::None,
            sha_sentryfile: ::std::option::Option::None,
            auth_code: ::std::option::Option::None,
            otp_type: ::std::option::Option::None,
            otp_value: ::std::option::Option::None,
            otp_identifier: ::std::option::Option::None,
            steam2_ticket_request: ::std::option::Option::None,
            sony_psn_ticket: ::std::option::Option::None,
            sony_psn_service_id: ::std::option::Option::None,
            create_new_psn_linked_account_if_needed: ::std::option::Option::None,
            sony_psn_name: ::std::option::Option::None,
            game_server_app_id: ::std::option::Option::None,
            steamguard_dont_remember_computer: ::std::option::Option::None,
            machine_name: ::std::option::Option::None,
            machine_name_userchosen: ::std::option::Option::None,
            country_override: ::std::option::Option::None,
            client_instance_id: ::std::option::Option::None,
            two_factor_code: ::std::option::Option::None,
            supports_rate_limit_response: ::std::option::Option::None,
            web_logon_nonce: ::std::option::Option::None,
            priority_reason: ::std::option::Option::None,
            embedded_client_secret: ::steam_vent_proto_common::protobuf::MessageField::none(),
            disable_partner_autogrants: ::std::option::Option::None,
            access_token: ::std::option::Option::None,
            is_chrome_os: ::std::option::Option::None,
            is_steam_box_deprecated: ::std::option::Option::None,
            is_steam_deck_deprecated: ::std::option::Option::None,
            is_tesla_deprecated: ::std::option::Option::None,
            gaming_device_type: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgClientLogonResponse)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgClientLogonResponse {
    // message fields
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.eresult)
    pub eresult: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.legacy_out_of_game_heartbeat_seconds)
    pub legacy_out_of_game_heartbeat_seconds: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.heartbeat_seconds)
    pub heartbeat_seconds: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.deprecated_public_ip)
    pub deprecated_public_ip: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.rtime32_server_time)
    pub rtime32_server_time: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.account_flags)
    pub account_flags: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.cell_id)
    pub cell_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.email_domain)
    pub email_domain: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.steam2_ticket)
    pub steam2_ticket: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.eresult_extended)
    pub eresult_extended: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.cell_id_ping_threshold)
    pub cell_id_ping_threshold: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.deprecated_use_pics)
    pub deprecated_use_pics: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.vanity_url)
    pub vanity_url: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.public_ip)
    pub public_ip: ::steam_vent_proto_common::protobuf::MessageField<super::steammessages_base::CMsgIPAddress>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.user_country)
    pub user_country: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.client_supplied_steamid)
    pub client_supplied_steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.ip_country_code)
    pub ip_country_code: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.parental_settings)
    pub parental_settings: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.parental_setting_signature)
    pub parental_setting_signature: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.count_loginfailures_to_migrate)
    pub count_loginfailures_to_migrate: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.count_disconnects_to_migrate)
    pub count_disconnects_to_migrate: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.ogs_data_report_time_window)
    pub ogs_data_report_time_window: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.client_instance_id)
    pub client_instance_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.force_client_update_check)
    pub force_client_update_check: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.agreement_session_url)
    pub agreement_session_url: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.token_id)
    pub token_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgClientLogonResponse.family_group_id)
    pub family_group_id: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgClientLogonResponse.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional int32 eresult = 1;

    pub fn eresult(&self) -> i32 {
        self.eresult.unwrap_or(2i32)
    }

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

    pub fn has_eresult(&self) -> bool {
        self.eresult.is_some()
    }

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

    // optional int32 legacy_out_of_game_heartbeat_seconds = 2;

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

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

    pub fn has_legacy_out_of_game_heartbeat_seconds(&self) -> bool {
        self.legacy_out_of_game_heartbeat_seconds.is_some()
    }

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

    // optional int32 heartbeat_seconds = 3;

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

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

    pub fn has_heartbeat_seconds(&self) -> bool {
        self.heartbeat_seconds.is_some()
    }

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

    // optional uint32 deprecated_public_ip = 4;

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

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

    pub fn has_deprecated_public_ip(&self) -> bool {
        self.deprecated_public_ip.is_some()
    }

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

    // optional fixed32 rtime32_server_time = 5;

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

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

    pub fn has_rtime32_server_time(&self) -> bool {
        self.rtime32_server_time.is_some()
    }

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

    // optional uint32 account_flags = 6;

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

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

    pub fn has_account_flags(&self) -> bool {
        self.account_flags.is_some()
    }

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

    // optional uint32 cell_id = 7;

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

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

    pub fn has_cell_id(&self) -> bool {
        self.cell_id.is_some()
    }

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

    // optional string email_domain = 8;

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

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

    pub fn has_email_domain(&self) -> bool {
        self.email_domain.is_some()
    }

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

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

    // optional bytes steam2_ticket = 9;

    pub fn steam2_ticket(&self) -> &[u8] {
        match self.steam2_ticket.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

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

    pub fn has_steam2_ticket(&self) -> bool {
        self.steam2_ticket.is_some()
    }

    // Param is passed by value, moved
    pub fn set_steam2_ticket(&mut self, v: ::std::vec::Vec<u8>) {
        self.steam2_ticket = ::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_steam2_ticket(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.steam2_ticket.is_none() {
            self.steam2_ticket = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.steam2_ticket.as_mut().unwrap()
    }

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

    // optional int32 eresult_extended = 10;

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

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

    pub fn has_eresult_extended(&self) -> bool {
        self.eresult_extended.is_some()
    }

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

    // optional uint32 cell_id_ping_threshold = 12;

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

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

    pub fn has_cell_id_ping_threshold(&self) -> bool {
        self.cell_id_ping_threshold.is_some()
    }

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

    // optional bool deprecated_use_pics = 13;

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

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

    pub fn has_deprecated_use_pics(&self) -> bool {
        self.deprecated_use_pics.is_some()
    }

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

    // optional string vanity_url = 14;

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

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

    pub fn has_vanity_url(&self) -> bool {
        self.vanity_url.is_some()
    }

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

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

    // optional string user_country = 16;

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

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

    pub fn has_user_country(&self) -> bool {
        self.user_country.is_some()
    }

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

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

    // optional fixed64 client_supplied_steamid = 20;

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

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

    pub fn has_client_supplied_steamid(&self) -> bool {
        self.client_supplied_steamid.is_some()
    }

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

    // optional string ip_country_code = 21;

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

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

    pub fn has_ip_country_code(&self) -> bool {
        self.ip_country_code.is_some()
    }

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

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

    // optional bytes parental_settings = 22;

    pub fn parental_settings(&self) -> &[u8] {
        match self.parental_settings.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

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

    pub fn has_parental_settings(&self) -> bool {
        self.parental_settings.is_some()
    }

    // Param is passed by value, moved
    pub fn set_parental_settings(&mut self, v: ::std::vec::Vec<u8>) {
        self.parental_settings = ::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_parental_settings(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.parental_settings.is_none() {
            self.parental_settings = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.parental_settings.as_mut().unwrap()
    }

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

    // optional bytes parental_setting_signature = 23;

    pub fn parental_setting_signature(&self) -> &[u8] {
        match self.parental_setting_signature.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

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

    pub fn has_parental_setting_signature(&self) -> bool {
        self.parental_setting_signature.is_some()
    }

    // Param is passed by value, moved
    pub fn set_parental_setting_signature(&mut self, v: ::std::vec::Vec<u8>) {
        self.parental_setting_signature = ::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_parental_setting_signature(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.parental_setting_signature.is_none() {
            self.parental_setting_signature = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.parental_setting_signature.as_mut().unwrap()
    }

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

    // optional int32 count_loginfailures_to_migrate = 24;

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

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

    pub fn has_count_loginfailures_to_migrate(&self) -> bool {
        self.count_loginfailures_to_migrate.is_some()
    }

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

    // optional int32 count_disconnects_to_migrate = 25;

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

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

    pub fn has_count_disconnects_to_migrate(&self) -> bool {
        self.count_disconnects_to_migrate.is_some()
    }

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

    // optional int32 ogs_data_report_time_window = 26;

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

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

    pub fn has_ogs_data_report_time_window(&self) -> bool {
        self.ogs_data_report_time_window.is_some()
    }

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

    // optional uint64 client_instance_id = 27;

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

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

    pub fn has_client_instance_id(&self) -> bool {
        self.client_instance_id.is_some()
    }

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

    // optional bool force_client_update_check = 28;

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

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

    pub fn has_force_client_update_check(&self) -> bool {
        self.force_client_update_check.is_some()
    }

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

    // optional string agreement_session_url = 29;

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

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

    pub fn has_agreement_session_url(&self) -> bool {
        self.agreement_session_url.is_some()
    }

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

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

    // optional uint64 token_id = 30;

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

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

    pub fn has_token_id(&self) -> bool {
        self.token_id.is_some()
    }

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

    // optional uint64 family_group_id = 31;

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

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

    pub fn has_family_group_id(&self) -> bool {
        self.family_group_id.is_some()
    }

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

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

    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.eresult = ::std::option::Option::Some(is.read_int32()?);
                },
                16 => {
                    self.legacy_out_of_game_heartbeat_seconds = ::std::option::Option::Some(is.read_int32()?);
                },
                24 => {
                    self.heartbeat_seconds = ::std::option::Option::Some(is.read_int32()?);
                },
                32 => {
                    self.deprecated_public_ip = ::std::option::Option::Some(is.read_uint32()?);
                },
                45 => {
                    self.rtime32_server_time = ::std::option::Option::Some(is.read_fixed32()?);
                },
                48 => {
                    self.account_flags = ::std::option::Option::Some(is.read_uint32()?);
                },
                56 => {
                    self.cell_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                66 => {
                    self.email_domain = ::std::option::Option::Some(is.read_string()?);
                },
                74 => {
                    self.steam2_ticket = ::std::option::Option::Some(is.read_bytes()?);
                },
                80 => {
                    self.eresult_extended = ::std::option::Option::Some(is.read_int32()?);
                },
                96 => {
                    self.cell_id_ping_threshold = ::std::option::Option::Some(is.read_uint32()?);
                },
                104 => {
                    self.deprecated_use_pics = ::std::option::Option::Some(is.read_bool()?);
                },
                114 => {
                    self.vanity_url = ::std::option::Option::Some(is.read_string()?);
                },
                122 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.public_ip)?;
                },
                130 => {
                    self.user_country = ::std::option::Option::Some(is.read_string()?);
                },
                161 => {
                    self.client_supplied_steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                170 => {
                    self.ip_country_code = ::std::option::Option::Some(is.read_string()?);
                },
                178 => {
                    self.parental_settings = ::std::option::Option::Some(is.read_bytes()?);
                },
                186 => {
                    self.parental_setting_signature = ::std::option::Option::Some(is.read_bytes()?);
                },
                192 => {
                    self.count_loginfailures_to_migrate = ::std::option::Option::Some(is.read_int32()?);
                },
                200 => {
                    self.count_disconnects_to_migrate = ::std::option::Option::Some(is.read_int32()?);
                },
                208 => {
                    self.ogs_data_report_time_window = ::std::option::Option::Some(is.read_int32()?);
                },
                216 => {
                    self.client_instance_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                224 => {
                    self.force_client_update_check = ::std::option::Option::Some(is.read_bool()?);
                },
                234 => {
                    self.agreement_session_url = ::std::option::Option::Some(is.read_string()?);
                },
                240 => {
                    self.token_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                248 => {
                    self.family_group_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.eresult {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
        }
        if let Some(v) = self.legacy_out_of_game_heartbeat_seconds {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
        }
        if let Some(v) = self.heartbeat_seconds {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v);
        }
        if let Some(v) = self.deprecated_public_ip {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.rtime32_server_time {
            my_size += 1 + 4;
        }
        if let Some(v) = self.account_flags {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.cell_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.email_domain.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(8, &v);
        }
        if let Some(v) = self.steam2_ticket.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(9, &v);
        }
        if let Some(v) = self.eresult_extended {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(10, v);
        }
        if let Some(v) = self.cell_id_ping_threshold {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(12, v);
        }
        if let Some(v) = self.deprecated_use_pics {
            my_size += 1 + 1;
        }
        if let Some(v) = self.vanity_url.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(14, &v);
        }
        if let Some(v) = self.public_ip.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.user_country.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(16, &v);
        }
        if let Some(v) = self.client_supplied_steamid {
            my_size += 2 + 8;
        }
        if let Some(v) = self.ip_country_code.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(21, &v);
        }
        if let Some(v) = self.parental_settings.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(22, &v);
        }
        if let Some(v) = self.parental_setting_signature.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(23, &v);
        }
        if let Some(v) = self.count_loginfailures_to_migrate {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(24, v);
        }
        if let Some(v) = self.count_disconnects_to_migrate {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(25, v);
        }
        if let Some(v) = self.ogs_data_report_time_window {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(26, v);
        }
        if let Some(v) = self.client_instance_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(27, v);
        }
        if let Some(v) = self.force_client_update_check {
            my_size += 2 + 1;
        }
        if let Some(v) = self.agreement_session_url.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(29, &v);
        }
        if let Some(v) = self.token_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(30, v);
        }
        if let Some(v) = self.family_group_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(31, 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.eresult {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.legacy_out_of_game_heartbeat_seconds {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.heartbeat_seconds {
            os.write_int32(3, v)?;
        }
        if let Some(v) = self.deprecated_public_ip {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.rtime32_server_time {
            os.write_fixed32(5, v)?;
        }
        if let Some(v) = self.account_flags {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.cell_id {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.email_domain.as_ref() {
            os.write_string(8, v)?;
        }
        if let Some(v) = self.steam2_ticket.as_ref() {
            os.write_bytes(9, v)?;
        }
        if let Some(v) = self.eresult_extended {
            os.write_int32(10, v)?;
        }
        if let Some(v) = self.cell_id_ping_threshold {
            os.write_uint32(12, v)?;
        }
        if let Some(v) = self.deprecated_use_pics {
            os.write_bool(13, v)?;
        }
        if let Some(v) = self.vanity_url.as_ref() {
            os.write_string(14, v)?;
        }
        if let Some(v) = self.public_ip.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(15, v, os)?;
        }
        if let Some(v) = self.user_country.as_ref() {
            os.write_string(16, v)?;
        }
        if let Some(v) = self.client_supplied_steamid {
            os.write_fixed64(20, v)?;
        }
        if let Some(v) = self.ip_country_code.as_ref() {
            os.write_string(21, v)?;
        }
        if let Some(v) = self.parental_settings.as_ref() {
            os.write_bytes(22, v)?;
        }
        if let Some(v) = self.parental_setting_signature.as_ref() {
            os.write_bytes(23, v)?;
        }
        if let Some(v) = self.count_loginfailures_to_migrate {
            os.write_int32(24, v)?;
        }
        if let Some(v) = self.count_disconnects_to_migrate {
            os.write_int32(25, v)?;
        }
        if let Some(v) = self.ogs_data_report_time_window {
            os.write_int32(26, v)?;
        }
        if let Some(v) = self.client_instance_id {
            os.write_uint64(27, v)?;
        }
        if let Some(v) = self.force_client_update_check {
            os.write_bool(28, v)?;
        }
        if let Some(v) = self.agreement_session_url.as_ref() {
            os.write_string(29, v)?;
        }
        if let Some(v) = self.token_id {
            os.write_uint64(30, v)?;
        }
        if let Some(v) = self.family_group_id {
            os.write_uint64(31, 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() -> CMsgClientLogonResponse {
        CMsgClientLogonResponse::new()
    }

    fn clear(&mut self) {
        self.eresult = ::std::option::Option::None;
        self.legacy_out_of_game_heartbeat_seconds = ::std::option::Option::None;
        self.heartbeat_seconds = ::std::option::Option::None;
        self.deprecated_public_ip = ::std::option::Option::None;
        self.rtime32_server_time = ::std::option::Option::None;
        self.account_flags = ::std::option::Option::None;
        self.cell_id = ::std::option::Option::None;
        self.email_domain = ::std::option::Option::None;
        self.steam2_ticket = ::std::option::Option::None;
        self.eresult_extended = ::std::option::Option::None;
        self.cell_id_ping_threshold = ::std::option::Option::None;
        self.deprecated_use_pics = ::std::option::Option::None;
        self.vanity_url = ::std::option::Option::None;
        self.public_ip.clear();
        self.user_country = ::std::option::Option::None;
        self.client_supplied_steamid = ::std::option::Option::None;
        self.ip_country_code = ::std::option::Option::None;
        self.parental_settings = ::std::option::Option::None;
        self.parental_setting_signature = ::std::option::Option::None;
        self.count_loginfailures_to_migrate = ::std::option::Option::None;
        self.count_disconnects_to_migrate = ::std::option::Option::None;
        self.ogs_data_report_time_window = ::std::option::Option::None;
        self.client_instance_id = ::std::option::Option::None;
        self.force_client_update_check = ::std::option::Option::None;
        self.agreement_session_url = ::std::option::Option::None;
        self.token_id = ::std::option::Option::None;
        self.family_group_id = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgClientLogonResponse {
        static instance: CMsgClientLogonResponse = CMsgClientLogonResponse {
            eresult: ::std::option::Option::None,
            legacy_out_of_game_heartbeat_seconds: ::std::option::Option::None,
            heartbeat_seconds: ::std::option::Option::None,
            deprecated_public_ip: ::std::option::Option::None,
            rtime32_server_time: ::std::option::Option::None,
            account_flags: ::std::option::Option::None,
            cell_id: ::std::option::Option::None,
            email_domain: ::std::option::Option::None,
            steam2_ticket: ::std::option::Option::None,
            eresult_extended: ::std::option::Option::None,
            cell_id_ping_threshold: ::std::option::Option::None,
            deprecated_use_pics: ::std::option::Option::None,
            vanity_url: ::std::option::Option::None,
            public_ip: ::steam_vent_proto_common::protobuf::MessageField::none(),
            user_country: ::std::option::Option::None,
            client_supplied_steamid: ::std::option::Option::None,
            ip_country_code: ::std::option::Option::None,
            parental_settings: ::std::option::Option::None,
            parental_setting_signature: ::std::option::Option::None,
            count_loginfailures_to_migrate: ::std::option::Option::None,
            count_disconnects_to_migrate: ::std::option::Option::None,
            ogs_data_report_time_window: ::std::option::Option::None,
            client_instance_id: ::std::option::Option::None,
            force_client_update_check: ::std::option::Option::None,
            agreement_session_url: ::std::option::Option::None,
            token_id: ::std::option::Option::None,
            family_group_id: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional int32 token_type = 1;

    pub fn token_type(&self) -> i32 {
        self.token_type.unwrap_or(-1i32)
    }

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

    pub fn has_token_type(&self) -> bool {
        self.token_type.is_some()
    }

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

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

    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.token_type = ::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.token_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_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.token_type {
            os.write_int32(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() -> CMsgClientRequestWebAPIAuthenticateUserNonce {
        CMsgClientRequestWebAPIAuthenticateUserNonce::new()
    }

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

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

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

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

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

    // optional int32 eresult = 1;

    pub fn eresult(&self) -> i32 {
        self.eresult.unwrap_or(2i32)
    }

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

    pub fn has_eresult(&self) -> bool {
        self.eresult.is_some()
    }

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

    // optional string webapi_authenticate_user_nonce = 11;

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

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

    pub fn has_webapi_authenticate_user_nonce(&self) -> bool {
        self.webapi_authenticate_user_nonce.is_some()
    }

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

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

    // optional int32 token_type = 3;

    pub fn token_type(&self) -> i32 {
        self.token_type.unwrap_or(-1i32)
    }

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

    pub fn has_token_type(&self) -> bool {
        self.token_type.is_some()
    }

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

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

    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.eresult = ::std::option::Option::Some(is.read_int32()?);
                },
                90 => {
                    self.webapi_authenticate_user_nonce = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.token_type = ::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.eresult {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
        }
        if let Some(v) = self.webapi_authenticate_user_nonce.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(11, &v);
        }
        if let Some(v) = self.token_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, 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.eresult {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.webapi_authenticate_user_nonce.as_ref() {
            os.write_string(11, v)?;
        }
        if let Some(v) = self.token_type {
            os.write_int32(3, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional int32 eresult = 1;

    pub fn eresult(&self) -> i32 {
        self.eresult.unwrap_or(2i32)
    }

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

    pub fn has_eresult(&self) -> bool {
        self.eresult.is_some()
    }

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

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

    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.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.eresult {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_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.eresult {
            os.write_int32(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() -> CMsgClientLoggedOff {
        CMsgClientLoggedOff::new()
    }

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

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

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

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

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

    // optional uint32 unique_id = 1;

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

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

    pub fn has_unique_id(&self) -> bool {
        self.unique_id.is_some()
    }

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

    // optional string login_key = 2;

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

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

    pub fn has_login_key(&self) -> bool {
        self.login_key.is_some()
    }

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

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

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

    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.unique_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                18 => {
                    self.login_key = ::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.unique_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.login_key.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_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.unique_id {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.login_key.as_ref() {
            os.write_string(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() -> CMsgClientNewLoginKey {
        CMsgClientNewLoginKey::new()
    }

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

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

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

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

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

    // optional uint32 unique_id = 1;

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

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

    pub fn has_unique_id(&self) -> bool {
        self.unique_id.is_some()
    }

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

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

    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.unique_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                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.unique_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_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.unique_id {
            os.write_uint32(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() -> CMsgClientNewLoginKeyAccepted {
        CMsgClientNewLoginKeyAccepted::new()
    }

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

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

// @@protoc_insertion_point(message:CMsgClientAccountInfo)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgClientAccountInfo {
    // message fields
    // @@protoc_insertion_point(field:CMsgClientAccountInfo.persona_name)
    pub persona_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientAccountInfo.ip_country)
    pub ip_country: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientAccountInfo.count_authed_computers)
    pub count_authed_computers: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgClientAccountInfo.account_flags)
    pub account_flags: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientAccountInfo.facebook_id)
    pub facebook_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgClientAccountInfo.facebook_name)
    pub facebook_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientAccountInfo.steamguard_machine_name_user_chosen)
    pub steamguard_machine_name_user_chosen: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgClientAccountInfo.is_phone_verified)
    pub is_phone_verified: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgClientAccountInfo.two_factor_state)
    pub two_factor_state: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgClientAccountInfo.is_phone_identifying)
    pub is_phone_identifying: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgClientAccountInfo.is_phone_needing_reverify)
    pub is_phone_needing_reverify: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgClientAccountInfo.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string persona_name = 1;

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

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

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

    pub fn has_ip_country(&self) -> bool {
        self.ip_country.is_some()
    }

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

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

    // optional int32 count_authed_computers = 5;

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

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

    pub fn has_count_authed_computers(&self) -> bool {
        self.count_authed_computers.is_some()
    }

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

    // optional uint32 account_flags = 7;

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

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

    pub fn has_account_flags(&self) -> bool {
        self.account_flags.is_some()
    }

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

    // optional uint64 facebook_id = 8;

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

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

    pub fn has_facebook_id(&self) -> bool {
        self.facebook_id.is_some()
    }

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

    // optional string facebook_name = 9;

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

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

    pub fn has_facebook_name(&self) -> bool {
        self.facebook_name.is_some()
    }

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

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

    // optional string steamguard_machine_name_user_chosen = 15;

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

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

    pub fn has_steamguard_machine_name_user_chosen(&self) -> bool {
        self.steamguard_machine_name_user_chosen.is_some()
    }

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

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

    // optional bool is_phone_verified = 16;

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

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

    pub fn has_is_phone_verified(&self) -> bool {
        self.is_phone_verified.is_some()
    }

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

    // optional uint32 two_factor_state = 17;

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

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

    pub fn has_two_factor_state(&self) -> bool {
        self.two_factor_state.is_some()
    }

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

    // optional bool is_phone_identifying = 18;

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

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

    pub fn has_is_phone_identifying(&self) -> bool {
        self.is_phone_identifying.is_some()
    }

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

    // optional bool is_phone_needing_reverify = 19;

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

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

    pub fn has_is_phone_needing_reverify(&self) -> bool {
        self.is_phone_needing_reverify.is_some()
    }

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

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

    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.persona_name = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.ip_country = ::std::option::Option::Some(is.read_string()?);
                },
                40 => {
                    self.count_authed_computers = ::std::option::Option::Some(is.read_int32()?);
                },
                56 => {
                    self.account_flags = ::std::option::Option::Some(is.read_uint32()?);
                },
                64 => {
                    self.facebook_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                74 => {
                    self.facebook_name = ::std::option::Option::Some(is.read_string()?);
                },
                122 => {
                    self.steamguard_machine_name_user_chosen = ::std::option::Option::Some(is.read_string()?);
                },
                128 => {
                    self.is_phone_verified = ::std::option::Option::Some(is.read_bool()?);
                },
                136 => {
                    self.two_factor_state = ::std::option::Option::Some(is.read_uint32()?);
                },
                144 => {
                    self.is_phone_identifying = ::std::option::Option::Some(is.read_bool()?);
                },
                152 => {
                    self.is_phone_needing_reverify = ::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.persona_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.ip_country.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.count_authed_computers {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v);
        }
        if let Some(v) = self.account_flags {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.facebook_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(8, v);
        }
        if let Some(v) = self.facebook_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &v);
        }
        if let Some(v) = self.steamguard_machine_name_user_chosen.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(15, &v);
        }
        if let Some(v) = self.is_phone_verified {
            my_size += 2 + 1;
        }
        if let Some(v) = self.two_factor_state {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(17, v);
        }
        if let Some(v) = self.is_phone_identifying {
            my_size += 2 + 1;
        }
        if let Some(v) = self.is_phone_needing_reverify {
            my_size += 2 + 1;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.persona_name.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.ip_country.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.count_authed_computers {
            os.write_int32(5, v)?;
        }
        if let Some(v) = self.account_flags {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.facebook_id {
            os.write_uint64(8, v)?;
        }
        if let Some(v) = self.facebook_name.as_ref() {
            os.write_string(9, v)?;
        }
        if let Some(v) = self.steamguard_machine_name_user_chosen.as_ref() {
            os.write_string(15, v)?;
        }
        if let Some(v) = self.is_phone_verified {
            os.write_bool(16, v)?;
        }
        if let Some(v) = self.two_factor_state {
            os.write_uint32(17, v)?;
        }
        if let Some(v) = self.is_phone_identifying {
            os.write_bool(18, v)?;
        }
        if let Some(v) = self.is_phone_needing_reverify {
            os.write_bool(19, 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() -> CMsgClientAccountInfo {
        CMsgClientAccountInfo::new()
    }

    fn clear(&mut self) {
        self.persona_name = ::std::option::Option::None;
        self.ip_country = ::std::option::Option::None;
        self.count_authed_computers = ::std::option::Option::None;
        self.account_flags = ::std::option::Option::None;
        self.facebook_id = ::std::option::Option::None;
        self.facebook_name = ::std::option::Option::None;
        self.steamguard_machine_name_user_chosen = ::std::option::Option::None;
        self.is_phone_verified = ::std::option::Option::None;
        self.two_factor_state = ::std::option::Option::None;
        self.is_phone_identifying = ::std::option::Option::None;
        self.is_phone_needing_reverify = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgClientAccountInfo {
        static instance: CMsgClientAccountInfo = CMsgClientAccountInfo {
            persona_name: ::std::option::Option::None,
            ip_country: ::std::option::Option::None,
            count_authed_computers: ::std::option::Option::None,
            account_flags: ::std::option::Option::None,
            facebook_id: ::std::option::Option::None,
            facebook_name: ::std::option::Option::None,
            steamguard_machine_name_user_chosen: ::std::option::Option::None,
            is_phone_verified: ::std::option::Option::None,
            two_factor_state: ::std::option::Option::None,
            is_phone_identifying: ::std::option::Option::None,
            is_phone_needing_reverify: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional fixed64 steamid = 1;

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

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

    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 {
                9 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                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.steamid {
            my_size += 1 + 8;
        }
        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.steamid {
            os.write_fixed64(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() -> CMsgClientChallengeRequest {
        CMsgClientChallengeRequest::new()
    }

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

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

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

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

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

    // optional fixed64 challenge = 1;

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

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

    pub fn has_challenge(&self) -> bool {
        self.challenge.is_some()
    }

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

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

    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 {
                9 => {
                    self.challenge = ::std::option::Option::Some(is.read_fixed64()?);
                },
                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.challenge {
            my_size += 1 + 8;
        }
        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.challenge {
            os.write_fixed64(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() -> CMsgClientChallengeResponse {
        CMsgClientChallengeResponse::new()
    }

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

    fn default_instance() -> &'static CMsgClientChallengeResponse {
        static instance: CMsgClientChallengeResponse = CMsgClientChallengeResponse {
            challenge: ::std::option::Option::None,
            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 CMsgClientHeartBeat {
    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::RpcMessageWithKind for CMsgClientHeartBeat {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgClientHeartBeat;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgClientServerTimestampRequest {
    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::RpcMessageWithKind for CMsgClientServerTimestampRequest {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgClientServerTimestampRequest;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgClientServerTimestampResponse {
    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::RpcMessageWithKind
for CMsgClientServerTimestampResponse {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgClientServerTimestampResponse;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgClientSecret {
    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 CMsgClientHello {
    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::RpcMessageWithKind for CMsgClientHello {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgClientHello;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgClientLogon {
    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::RpcMessageWithKind for CMsgClientLogon {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgClientLogon;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgClientLogonResponse {
    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::RpcMessageWithKind for CMsgClientLogonResponse {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgClientLogOnResponse;
}
impl ::steam_vent_proto_common::RpcMessage
for CMsgClientRequestWebAPIAuthenticateUserNonce {
    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 CMsgClientRequestWebAPIAuthenticateUserNonceResponse {
    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 CMsgClientLogOff {
    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::RpcMessageWithKind for CMsgClientLogOff {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgClientLogOff;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgClientLoggedOff {
    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::RpcMessageWithKind for CMsgClientLoggedOff {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgClientLoggedOff;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgClientNewLoginKey {
    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::RpcMessageWithKind for CMsgClientNewLoginKey {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgClientNewLoginKey;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgClientNewLoginKeyAccepted {
    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 CMsgClientAccountInfo {
    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::RpcMessageWithKind for CMsgClientAccountInfo {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgClientAccountInfo;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgClientChallengeRequest {
    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::RpcMessageWithKind for CMsgClientChallengeRequest {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgClientChallengeRequest;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgClientChallengeResponse {
    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::RpcMessageWithKind for CMsgClientChallengeResponse {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgClientChallengeResponse;
}
