steam-vent-proto 0.1.0

// This file is generated by rust-protobuf 2.24.1. Do not edit
// @generated

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

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

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `steammessages_credentials.steamclient.proto`

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

#[derive(PartialEq,Clone,Default)]
pub struct CCredentials_TestAvailablePassword_Request {
    // message fields
    password: ::protobuf::SingularField<::std::string::String>,
    sha_digest_password: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    account_name: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string password = 1;


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

    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 = ::protobuf::SingularField::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.set_default();
        }
        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 bytes sha_digest_password = 2;


    pub fn get_sha_digest_password(&self) -> &[u8] {
        match self.sha_digest_password.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_sha_digest_password(&mut self) {
        self.sha_digest_password.clear();
    }

    pub fn has_sha_digest_password(&self) -> bool {
        self.sha_digest_password.is_some()
    }

    // Param is passed by value, moved
    pub fn set_sha_digest_password(&mut self, v: ::std::vec::Vec<u8>) {
        self.sha_digest_password = ::protobuf::SingularField::some(v);
    }

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

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

    // optional string account_name = 3;


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

    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 = ::protobuf::SingularField::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.set_default();
        }
        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())
    }
}

impl ::protobuf::Message for CCredentials_TestAvailablePassword_Request {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.password)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.sha_digest_password)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.account_name)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.password.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.sha_digest_password.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(ref v) = self.account_name.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.password.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.sha_digest_password.as_ref() {
            os.write_bytes(2, &v)?;
        }
        if let Some(ref v) = self.account_name.as_ref() {
            os.write_string(3, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "password",
                |m: &CCredentials_TestAvailablePassword_Request| { &m.password },
                |m: &mut CCredentials_TestAvailablePassword_Request| { &mut m.password },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "sha_digest_password",
                |m: &CCredentials_TestAvailablePassword_Request| { &m.sha_digest_password },
                |m: &mut CCredentials_TestAvailablePassword_Request| { &mut m.sha_digest_password },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "account_name",
                |m: &CCredentials_TestAvailablePassword_Request| { &m.account_name },
                |m: &mut CCredentials_TestAvailablePassword_Request| { &mut m.account_name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_TestAvailablePassword_Request>(
                "CCredentials_TestAvailablePassword_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CCredentials_TestAvailablePassword_Request {
    fn clear(&mut self) {
        self.password.clear();
        self.sha_digest_password.clear();
        self.account_name.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional bool is_valid = 3;


    pub fn get_is_valid(&self) -> bool {
        self.is_valid.unwrap_or(false)
    }
    pub fn clear_is_valid(&mut self) {
        self.is_valid = ::std::option::Option::None;
    }

    pub fn has_is_valid(&self) -> bool {
        self.is_valid.is_some()
    }

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

impl ::protobuf::Message for CCredentials_TestAvailablePassword_Response {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_valid = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.is_valid {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.is_valid {
            os.write_bool(3, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_valid",
                |m: &CCredentials_TestAvailablePassword_Response| { &m.is_valid },
                |m: &mut CCredentials_TestAvailablePassword_Response| { &mut m.is_valid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_TestAvailablePassword_Response>(
                "CCredentials_TestAvailablePassword_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CCredentials_GetSteamGuardDetails_Request {
    // message fields
    include_new_authentications: ::std::option::Option<bool>,
    webcookie: ::protobuf::SingularField<::std::string::String>,
    timestamp_minimum_wanted: ::std::option::Option<u32>,
    ipaddress: ::std::option::Option<i32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bool include_new_authentications = 1;


    pub fn get_include_new_authentications(&self) -> bool {
        self.include_new_authentications.unwrap_or(true)
    }
    pub fn clear_include_new_authentications(&mut self) {
        self.include_new_authentications = ::std::option::Option::None;
    }

    pub fn has_include_new_authentications(&self) -> bool {
        self.include_new_authentications.is_some()
    }

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

    // optional string webcookie = 2;


    pub fn get_webcookie(&self) -> &str {
        match self.webcookie.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_webcookie(&mut self) {
        self.webcookie.clear();
    }

    pub fn has_webcookie(&self) -> bool {
        self.webcookie.is_some()
    }

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

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

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

    // optional fixed32 timestamp_minimum_wanted = 3;


    pub fn get_timestamp_minimum_wanted(&self) -> u32 {
        self.timestamp_minimum_wanted.unwrap_or(0)
    }
    pub fn clear_timestamp_minimum_wanted(&mut self) {
        self.timestamp_minimum_wanted = ::std::option::Option::None;
    }

    pub fn has_timestamp_minimum_wanted(&self) -> bool {
        self.timestamp_minimum_wanted.is_some()
    }

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

    // optional int32 ipaddress = 4;


    pub fn get_ipaddress(&self) -> i32 {
        self.ipaddress.unwrap_or(0)
    }
    pub fn clear_ipaddress(&mut self) {
        self.ipaddress = ::std::option::Option::None;
    }

    pub fn has_ipaddress(&self) -> bool {
        self.ipaddress.is_some()
    }

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

impl ::protobuf::Message for CCredentials_GetSteamGuardDetails_Request {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.include_new_authentications = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.webcookie)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.timestamp_minimum_wanted = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.ipaddress = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.include_new_authentications {
            my_size += 2;
        }
        if let Some(ref v) = self.webcookie.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.timestamp_minimum_wanted {
            my_size += 5;
        }
        if let Some(v) = self.ipaddress {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.include_new_authentications {
            os.write_bool(1, v)?;
        }
        if let Some(ref v) = self.webcookie.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.timestamp_minimum_wanted {
            os.write_fixed32(3, v)?;
        }
        if let Some(v) = self.ipaddress {
            os.write_int32(4, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "include_new_authentications",
                |m: &CCredentials_GetSteamGuardDetails_Request| { &m.include_new_authentications },
                |m: &mut CCredentials_GetSteamGuardDetails_Request| { &mut m.include_new_authentications },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "webcookie",
                |m: &CCredentials_GetSteamGuardDetails_Request| { &m.webcookie },
                |m: &mut CCredentials_GetSteamGuardDetails_Request| { &mut m.webcookie },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "timestamp_minimum_wanted",
                |m: &CCredentials_GetSteamGuardDetails_Request| { &m.timestamp_minimum_wanted },
                |m: &mut CCredentials_GetSteamGuardDetails_Request| { &mut m.timestamp_minimum_wanted },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "ipaddress",
                |m: &CCredentials_GetSteamGuardDetails_Request| { &m.ipaddress },
                |m: &mut CCredentials_GetSteamGuardDetails_Request| { &mut m.ipaddress },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_GetSteamGuardDetails_Request>(
                "CCredentials_GetSteamGuardDetails_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CCredentials_GetSteamGuardDetails_Request {
    fn clear(&mut self) {
        self.include_new_authentications = ::std::option::Option::None;
        self.webcookie.clear();
        self.timestamp_minimum_wanted = ::std::option::Option::None;
        self.ipaddress = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CCredentials_GetSteamGuardDetails_Response {
    // message fields
    is_steamguard_enabled: ::std::option::Option<bool>,
    timestamp_steamguard_enabled: ::std::option::Option<u32>,
    pub deprecated_newauthentication: ::protobuf::RepeatedField<CCredentials_GetSteamGuardDetails_Response_NewAuthentication>,
    deprecated_machine_name_userchosen: ::protobuf::SingularField<::std::string::String>,
    deprecated_timestamp_machine_steamguard_enabled: ::std::option::Option<u32>,
    deprecated_authentication_exists_from_geoloc_before_mintime: ::std::option::Option<bool>,
    deprecated_machine_id: ::std::option::Option<u64>,
    pub session_data: ::protobuf::RepeatedField<CCredentials_GetSteamGuardDetails_Response_SessionData>,
    is_twofactor_enabled: ::std::option::Option<bool>,
    timestamp_twofactor_enabled: ::std::option::Option<u32>,
    is_phone_verified: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bool is_steamguard_enabled = 1;


    pub fn get_is_steamguard_enabled(&self) -> bool {
        self.is_steamguard_enabled.unwrap_or(false)
    }
    pub fn clear_is_steamguard_enabled(&mut self) {
        self.is_steamguard_enabled = ::std::option::Option::None;
    }

    pub fn has_is_steamguard_enabled(&self) -> bool {
        self.is_steamguard_enabled.is_some()
    }

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

    // optional fixed32 timestamp_steamguard_enabled = 2;


    pub fn get_timestamp_steamguard_enabled(&self) -> u32 {
        self.timestamp_steamguard_enabled.unwrap_or(0)
    }
    pub fn clear_timestamp_steamguard_enabled(&mut self) {
        self.timestamp_steamguard_enabled = ::std::option::Option::None;
    }

    pub fn has_timestamp_steamguard_enabled(&self) -> bool {
        self.timestamp_steamguard_enabled.is_some()
    }

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

    // repeated .CCredentials_GetSteamGuardDetails_Response.NewAuthentication deprecated_newauthentication = 3;


    pub fn get_deprecated_newauthentication(&self) -> &[CCredentials_GetSteamGuardDetails_Response_NewAuthentication] {
        &self.deprecated_newauthentication
    }
    pub fn clear_deprecated_newauthentication(&mut self) {
        self.deprecated_newauthentication.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_deprecated_newauthentication(&mut self) -> &mut ::protobuf::RepeatedField<CCredentials_GetSteamGuardDetails_Response_NewAuthentication> {
        &mut self.deprecated_newauthentication
    }

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

    // optional string deprecated_machine_name_userchosen = 4;


    pub fn get_deprecated_machine_name_userchosen(&self) -> &str {
        match self.deprecated_machine_name_userchosen.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_deprecated_machine_name_userchosen(&mut self) {
        self.deprecated_machine_name_userchosen.clear();
    }

    pub fn has_deprecated_machine_name_userchosen(&self) -> bool {
        self.deprecated_machine_name_userchosen.is_some()
    }

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

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

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

    // optional fixed32 deprecated_timestamp_machine_steamguard_enabled = 5;


    pub fn get_deprecated_timestamp_machine_steamguard_enabled(&self) -> u32 {
        self.deprecated_timestamp_machine_steamguard_enabled.unwrap_or(0)
    }
    pub fn clear_deprecated_timestamp_machine_steamguard_enabled(&mut self) {
        self.deprecated_timestamp_machine_steamguard_enabled = ::std::option::Option::None;
    }

    pub fn has_deprecated_timestamp_machine_steamguard_enabled(&self) -> bool {
        self.deprecated_timestamp_machine_steamguard_enabled.is_some()
    }

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

    // optional bool deprecated_authentication_exists_from_geoloc_before_mintime = 6;


    pub fn get_deprecated_authentication_exists_from_geoloc_before_mintime(&self) -> bool {
        self.deprecated_authentication_exists_from_geoloc_before_mintime.unwrap_or(false)
    }
    pub fn clear_deprecated_authentication_exists_from_geoloc_before_mintime(&mut self) {
        self.deprecated_authentication_exists_from_geoloc_before_mintime = ::std::option::Option::None;
    }

    pub fn has_deprecated_authentication_exists_from_geoloc_before_mintime(&self) -> bool {
        self.deprecated_authentication_exists_from_geoloc_before_mintime.is_some()
    }

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

    // optional uint64 deprecated_machine_id = 7;


    pub fn get_deprecated_machine_id(&self) -> u64 {
        self.deprecated_machine_id.unwrap_or(0)
    }
    pub fn clear_deprecated_machine_id(&mut self) {
        self.deprecated_machine_id = ::std::option::Option::None;
    }

    pub fn has_deprecated_machine_id(&self) -> bool {
        self.deprecated_machine_id.is_some()
    }

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

    // repeated .CCredentials_GetSteamGuardDetails_Response.SessionData session_data = 8;


    pub fn get_session_data(&self) -> &[CCredentials_GetSteamGuardDetails_Response_SessionData] {
        &self.session_data
    }
    pub fn clear_session_data(&mut self) {
        self.session_data.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_session_data(&mut self) -> &mut ::protobuf::RepeatedField<CCredentials_GetSteamGuardDetails_Response_SessionData> {
        &mut self.session_data
    }

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

    // optional bool is_twofactor_enabled = 9;


    pub fn get_is_twofactor_enabled(&self) -> bool {
        self.is_twofactor_enabled.unwrap_or(false)
    }
    pub fn clear_is_twofactor_enabled(&mut self) {
        self.is_twofactor_enabled = ::std::option::Option::None;
    }

    pub fn has_is_twofactor_enabled(&self) -> bool {
        self.is_twofactor_enabled.is_some()
    }

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

    // optional fixed32 timestamp_twofactor_enabled = 10;


    pub fn get_timestamp_twofactor_enabled(&self) -> u32 {
        self.timestamp_twofactor_enabled.unwrap_or(0)
    }
    pub fn clear_timestamp_twofactor_enabled(&mut self) {
        self.timestamp_twofactor_enabled = ::std::option::Option::None;
    }

    pub fn has_timestamp_twofactor_enabled(&self) -> bool {
        self.timestamp_twofactor_enabled.is_some()
    }

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

    // optional bool is_phone_verified = 11;


    pub fn get_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);
    }
}

impl ::protobuf::Message for CCredentials_GetSteamGuardDetails_Response {
    fn is_initialized(&self) -> bool {
        for v in &self.deprecated_newauthentication {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.session_data {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_steamguard_enabled = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.timestamp_steamguard_enabled = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.deprecated_newauthentication)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.deprecated_machine_name_userchosen)?;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.deprecated_timestamp_machine_steamguard_enabled = ::std::option::Option::Some(tmp);
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.deprecated_authentication_exists_from_geoloc_before_mintime = ::std::option::Option::Some(tmp);
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.deprecated_machine_id = ::std::option::Option::Some(tmp);
                },
                8 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.session_data)?;
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_twofactor_enabled = ::std::option::Option::Some(tmp);
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.timestamp_twofactor_enabled = ::std::option::Option::Some(tmp);
                },
                11 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_phone_verified = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.is_steamguard_enabled {
            my_size += 2;
        }
        if let Some(v) = self.timestamp_steamguard_enabled {
            my_size += 5;
        }
        for value in &self.deprecated_newauthentication {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(ref v) = self.deprecated_machine_name_userchosen.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.deprecated_timestamp_machine_steamguard_enabled {
            my_size += 5;
        }
        if let Some(v) = self.deprecated_authentication_exists_from_geoloc_before_mintime {
            my_size += 2;
        }
        if let Some(v) = self.deprecated_machine_id {
            my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.session_data {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(v) = self.is_twofactor_enabled {
            my_size += 2;
        }
        if let Some(v) = self.timestamp_twofactor_enabled {
            my_size += 5;
        }
        if let Some(v) = self.is_phone_verified {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.is_steamguard_enabled {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.timestamp_steamguard_enabled {
            os.write_fixed32(2, v)?;
        }
        for v in &self.deprecated_newauthentication {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(ref v) = self.deprecated_machine_name_userchosen.as_ref() {
            os.write_string(4, &v)?;
        }
        if let Some(v) = self.deprecated_timestamp_machine_steamguard_enabled {
            os.write_fixed32(5, v)?;
        }
        if let Some(v) = self.deprecated_authentication_exists_from_geoloc_before_mintime {
            os.write_bool(6, v)?;
        }
        if let Some(v) = self.deprecated_machine_id {
            os.write_uint64(7, v)?;
        }
        for v in &self.session_data {
            os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(v) = self.is_twofactor_enabled {
            os.write_bool(9, v)?;
        }
        if let Some(v) = self.timestamp_twofactor_enabled {
            os.write_fixed32(10, v)?;
        }
        if let Some(v) = self.is_phone_verified {
            os.write_bool(11, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_steamguard_enabled",
                |m: &CCredentials_GetSteamGuardDetails_Response| { &m.is_steamguard_enabled },
                |m: &mut CCredentials_GetSteamGuardDetails_Response| { &mut m.is_steamguard_enabled },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "timestamp_steamguard_enabled",
                |m: &CCredentials_GetSteamGuardDetails_Response| { &m.timestamp_steamguard_enabled },
                |m: &mut CCredentials_GetSteamGuardDetails_Response| { &mut m.timestamp_steamguard_enabled },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CCredentials_GetSteamGuardDetails_Response_NewAuthentication>>(
                "deprecated_newauthentication",
                |m: &CCredentials_GetSteamGuardDetails_Response| { &m.deprecated_newauthentication },
                |m: &mut CCredentials_GetSteamGuardDetails_Response| { &mut m.deprecated_newauthentication },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "deprecated_machine_name_userchosen",
                |m: &CCredentials_GetSteamGuardDetails_Response| { &m.deprecated_machine_name_userchosen },
                |m: &mut CCredentials_GetSteamGuardDetails_Response| { &mut m.deprecated_machine_name_userchosen },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "deprecated_timestamp_machine_steamguard_enabled",
                |m: &CCredentials_GetSteamGuardDetails_Response| { &m.deprecated_timestamp_machine_steamguard_enabled },
                |m: &mut CCredentials_GetSteamGuardDetails_Response| { &mut m.deprecated_timestamp_machine_steamguard_enabled },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "deprecated_authentication_exists_from_geoloc_before_mintime",
                |m: &CCredentials_GetSteamGuardDetails_Response| { &m.deprecated_authentication_exists_from_geoloc_before_mintime },
                |m: &mut CCredentials_GetSteamGuardDetails_Response| { &mut m.deprecated_authentication_exists_from_geoloc_before_mintime },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "deprecated_machine_id",
                |m: &CCredentials_GetSteamGuardDetails_Response| { &m.deprecated_machine_id },
                |m: &mut CCredentials_GetSteamGuardDetails_Response| { &mut m.deprecated_machine_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CCredentials_GetSteamGuardDetails_Response_SessionData>>(
                "session_data",
                |m: &CCredentials_GetSteamGuardDetails_Response| { &m.session_data },
                |m: &mut CCredentials_GetSteamGuardDetails_Response| { &mut m.session_data },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_twofactor_enabled",
                |m: &CCredentials_GetSteamGuardDetails_Response| { &m.is_twofactor_enabled },
                |m: &mut CCredentials_GetSteamGuardDetails_Response| { &mut m.is_twofactor_enabled },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "timestamp_twofactor_enabled",
                |m: &CCredentials_GetSteamGuardDetails_Response| { &m.timestamp_twofactor_enabled },
                |m: &mut CCredentials_GetSteamGuardDetails_Response| { &mut m.timestamp_twofactor_enabled },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_phone_verified",
                |m: &CCredentials_GetSteamGuardDetails_Response| { &m.is_phone_verified },
                |m: &mut CCredentials_GetSteamGuardDetails_Response| { &mut m.is_phone_verified },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_GetSteamGuardDetails_Response>(
                "CCredentials_GetSteamGuardDetails_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CCredentials_GetSteamGuardDetails_Response {
    fn clear(&mut self) {
        self.is_steamguard_enabled = ::std::option::Option::None;
        self.timestamp_steamguard_enabled = ::std::option::Option::None;
        self.deprecated_newauthentication.clear();
        self.deprecated_machine_name_userchosen.clear();
        self.deprecated_timestamp_machine_steamguard_enabled = ::std::option::Option::None;
        self.deprecated_authentication_exists_from_geoloc_before_mintime = ::std::option::Option::None;
        self.deprecated_machine_id = ::std::option::Option::None;
        self.session_data.clear();
        self.is_twofactor_enabled = ::std::option::Option::None;
        self.timestamp_twofactor_enabled = ::std::option::Option::None;
        self.is_phone_verified = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CCredentials_GetSteamGuardDetails_Response_NewAuthentication {
    // message fields
    timestamp_steamguard_enabled: ::std::option::Option<u32>,
    is_web_cookie: ::std::option::Option<bool>,
    ipaddress: ::std::option::Option<i32>,
    geoloc_info: ::protobuf::SingularField<::std::string::String>,
    is_remembered: ::std::option::Option<bool>,
    machine_name_user_supplied: ::protobuf::SingularField<::std::string::String>,
    status: ::std::option::Option<i32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed32 timestamp_steamguard_enabled = 1;


    pub fn get_timestamp_steamguard_enabled(&self) -> u32 {
        self.timestamp_steamguard_enabled.unwrap_or(0)
    }
    pub fn clear_timestamp_steamguard_enabled(&mut self) {
        self.timestamp_steamguard_enabled = ::std::option::Option::None;
    }

    pub fn has_timestamp_steamguard_enabled(&self) -> bool {
        self.timestamp_steamguard_enabled.is_some()
    }

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

    // optional bool is_web_cookie = 2;


    pub fn get_is_web_cookie(&self) -> bool {
        self.is_web_cookie.unwrap_or(false)
    }
    pub fn clear_is_web_cookie(&mut self) {
        self.is_web_cookie = ::std::option::Option::None;
    }

    pub fn has_is_web_cookie(&self) -> bool {
        self.is_web_cookie.is_some()
    }

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

    // optional int32 ipaddress = 3;


    pub fn get_ipaddress(&self) -> i32 {
        self.ipaddress.unwrap_or(0)
    }
    pub fn clear_ipaddress(&mut self) {
        self.ipaddress = ::std::option::Option::None;
    }

    pub fn has_ipaddress(&self) -> bool {
        self.ipaddress.is_some()
    }

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

    // optional string geoloc_info = 4;


    pub fn get_geoloc_info(&self) -> &str {
        match self.geoloc_info.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_geoloc_info(&mut self) {
        self.geoloc_info.clear();
    }

    pub fn has_geoloc_info(&self) -> bool {
        self.geoloc_info.is_some()
    }

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

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

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

    // optional bool is_remembered = 5;


    pub fn get_is_remembered(&self) -> bool {
        self.is_remembered.unwrap_or(false)
    }
    pub fn clear_is_remembered(&mut self) {
        self.is_remembered = ::std::option::Option::None;
    }

    pub fn has_is_remembered(&self) -> bool {
        self.is_remembered.is_some()
    }

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

    // optional string machine_name_user_supplied = 6;


    pub fn get_machine_name_user_supplied(&self) -> &str {
        match self.machine_name_user_supplied.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_machine_name_user_supplied(&mut self) {
        self.machine_name_user_supplied.clear();
    }

    pub fn has_machine_name_user_supplied(&self) -> bool {
        self.machine_name_user_supplied.is_some()
    }

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

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

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

    // optional int32 status = 7;


    pub fn get_status(&self) -> i32 {
        self.status.unwrap_or(0)
    }
    pub fn clear_status(&mut self) {
        self.status = ::std::option::Option::None;
    }

    pub fn has_status(&self) -> bool {
        self.status.is_some()
    }

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

impl ::protobuf::Message for CCredentials_GetSteamGuardDetails_Response_NewAuthentication {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.timestamp_steamguard_enabled = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_web_cookie = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.ipaddress = ::std::option::Option::Some(tmp);
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.geoloc_info)?;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_remembered = ::std::option::Option::Some(tmp);
                },
                6 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.machine_name_user_supplied)?;
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.status = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.timestamp_steamguard_enabled {
            my_size += 5;
        }
        if let Some(v) = self.is_web_cookie {
            my_size += 2;
        }
        if let Some(v) = self.ipaddress {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.geoloc_info.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.is_remembered {
            my_size += 2;
        }
        if let Some(ref v) = self.machine_name_user_supplied.as_ref() {
            my_size += ::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.status {
            my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.timestamp_steamguard_enabled {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.is_web_cookie {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.ipaddress {
            os.write_int32(3, v)?;
        }
        if let Some(ref v) = self.geoloc_info.as_ref() {
            os.write_string(4, &v)?;
        }
        if let Some(v) = self.is_remembered {
            os.write_bool(5, v)?;
        }
        if let Some(ref v) = self.machine_name_user_supplied.as_ref() {
            os.write_string(6, &v)?;
        }
        if let Some(v) = self.status {
            os.write_int32(7, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "timestamp_steamguard_enabled",
                |m: &CCredentials_GetSteamGuardDetails_Response_NewAuthentication| { &m.timestamp_steamguard_enabled },
                |m: &mut CCredentials_GetSteamGuardDetails_Response_NewAuthentication| { &mut m.timestamp_steamguard_enabled },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_web_cookie",
                |m: &CCredentials_GetSteamGuardDetails_Response_NewAuthentication| { &m.is_web_cookie },
                |m: &mut CCredentials_GetSteamGuardDetails_Response_NewAuthentication| { &mut m.is_web_cookie },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "ipaddress",
                |m: &CCredentials_GetSteamGuardDetails_Response_NewAuthentication| { &m.ipaddress },
                |m: &mut CCredentials_GetSteamGuardDetails_Response_NewAuthentication| { &mut m.ipaddress },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "geoloc_info",
                |m: &CCredentials_GetSteamGuardDetails_Response_NewAuthentication| { &m.geoloc_info },
                |m: &mut CCredentials_GetSteamGuardDetails_Response_NewAuthentication| { &mut m.geoloc_info },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_remembered",
                |m: &CCredentials_GetSteamGuardDetails_Response_NewAuthentication| { &m.is_remembered },
                |m: &mut CCredentials_GetSteamGuardDetails_Response_NewAuthentication| { &mut m.is_remembered },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "machine_name_user_supplied",
                |m: &CCredentials_GetSteamGuardDetails_Response_NewAuthentication| { &m.machine_name_user_supplied },
                |m: &mut CCredentials_GetSteamGuardDetails_Response_NewAuthentication| { &mut m.machine_name_user_supplied },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "status",
                |m: &CCredentials_GetSteamGuardDetails_Response_NewAuthentication| { &m.status },
                |m: &mut CCredentials_GetSteamGuardDetails_Response_NewAuthentication| { &mut m.status },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_GetSteamGuardDetails_Response_NewAuthentication>(
                "CCredentials_GetSteamGuardDetails_Response.NewAuthentication",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CCredentials_GetSteamGuardDetails_Response_NewAuthentication {
    fn clear(&mut self) {
        self.timestamp_steamguard_enabled = ::std::option::Option::None;
        self.is_web_cookie = ::std::option::Option::None;
        self.ipaddress = ::std::option::Option::None;
        self.geoloc_info.clear();
        self.is_remembered = ::std::option::Option::None;
        self.machine_name_user_supplied.clear();
        self.status = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CCredentials_GetSteamGuardDetails_Response_SessionData {
    // message fields
    machine_id: ::std::option::Option<u64>,
    machine_name_userchosen: ::protobuf::SingularField<::std::string::String>,
    timestamp_machine_steamguard_enabled: ::std::option::Option<u32>,
    authentication_exists_from_geoloc_before_mintime: ::std::option::Option<bool>,
    pub newauthentication: ::protobuf::RepeatedField<CCredentials_GetSteamGuardDetails_Response_NewAuthentication>,
    authentication_exists_from_same_ip_before_mintime: ::std::option::Option<bool>,
    public_ipv4: ::std::option::Option<u32>,
    public_ip_address: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint64 machine_id = 1;


    pub fn get_machine_id(&self) -> u64 {
        self.machine_id.unwrap_or(0)
    }
    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: u64) {
        self.machine_id = ::std::option::Option::Some(v);
    }

    // optional string machine_name_userchosen = 2;


    pub fn get_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.clear();
    }

    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 = ::protobuf::SingularField::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.set_default();
        }
        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 fixed32 timestamp_machine_steamguard_enabled = 3;


    pub fn get_timestamp_machine_steamguard_enabled(&self) -> u32 {
        self.timestamp_machine_steamguard_enabled.unwrap_or(0)
    }
    pub fn clear_timestamp_machine_steamguard_enabled(&mut self) {
        self.timestamp_machine_steamguard_enabled = ::std::option::Option::None;
    }

    pub fn has_timestamp_machine_steamguard_enabled(&self) -> bool {
        self.timestamp_machine_steamguard_enabled.is_some()
    }

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

    // optional bool authentication_exists_from_geoloc_before_mintime = 4;


    pub fn get_authentication_exists_from_geoloc_before_mintime(&self) -> bool {
        self.authentication_exists_from_geoloc_before_mintime.unwrap_or(false)
    }
    pub fn clear_authentication_exists_from_geoloc_before_mintime(&mut self) {
        self.authentication_exists_from_geoloc_before_mintime = ::std::option::Option::None;
    }

    pub fn has_authentication_exists_from_geoloc_before_mintime(&self) -> bool {
        self.authentication_exists_from_geoloc_before_mintime.is_some()
    }

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

    // repeated .CCredentials_GetSteamGuardDetails_Response.NewAuthentication newauthentication = 5;


    pub fn get_newauthentication(&self) -> &[CCredentials_GetSteamGuardDetails_Response_NewAuthentication] {
        &self.newauthentication
    }
    pub fn clear_newauthentication(&mut self) {
        self.newauthentication.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_newauthentication(&mut self) -> &mut ::protobuf::RepeatedField<CCredentials_GetSteamGuardDetails_Response_NewAuthentication> {
        &mut self.newauthentication
    }

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

    // optional bool authentication_exists_from_same_ip_before_mintime = 6;


    pub fn get_authentication_exists_from_same_ip_before_mintime(&self) -> bool {
        self.authentication_exists_from_same_ip_before_mintime.unwrap_or(false)
    }
    pub fn clear_authentication_exists_from_same_ip_before_mintime(&mut self) {
        self.authentication_exists_from_same_ip_before_mintime = ::std::option::Option::None;
    }

    pub fn has_authentication_exists_from_same_ip_before_mintime(&self) -> bool {
        self.authentication_exists_from_same_ip_before_mintime.is_some()
    }

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

    // optional uint32 public_ipv4 = 7;


    pub fn get_public_ipv4(&self) -> u32 {
        self.public_ipv4.unwrap_or(0)
    }
    pub fn clear_public_ipv4(&mut self) {
        self.public_ipv4 = ::std::option::Option::None;
    }

    pub fn has_public_ipv4(&self) -> bool {
        self.public_ipv4.is_some()
    }

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

    // optional string public_ip_address = 8;


    pub fn get_public_ip_address(&self) -> &str {
        match self.public_ip_address.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_public_ip_address(&mut self) {
        self.public_ip_address.clear();
    }

    pub fn has_public_ip_address(&self) -> bool {
        self.public_ip_address.is_some()
    }

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

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

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

impl ::protobuf::Message for CCredentials_GetSteamGuardDetails_Response_SessionData {
    fn is_initialized(&self) -> bool {
        for v in &self.newauthentication {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.machine_id = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.machine_name_userchosen)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.timestamp_machine_steamguard_enabled = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.authentication_exists_from_geoloc_before_mintime = ::std::option::Option::Some(tmp);
                },
                5 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.newauthentication)?;
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.authentication_exists_from_same_ip_before_mintime = ::std::option::Option::Some(tmp);
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.public_ipv4 = ::std::option::Option::Some(tmp);
                },
                8 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.public_ip_address)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.machine_id {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.machine_name_userchosen.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.timestamp_machine_steamguard_enabled {
            my_size += 5;
        }
        if let Some(v) = self.authentication_exists_from_geoloc_before_mintime {
            my_size += 2;
        }
        for value in &self.newauthentication {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(v) = self.authentication_exists_from_same_ip_before_mintime {
            my_size += 2;
        }
        if let Some(v) = self.public_ipv4 {
            my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.public_ip_address.as_ref() {
            my_size += ::protobuf::rt::string_size(8, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.machine_id {
            os.write_uint64(1, v)?;
        }
        if let Some(ref v) = self.machine_name_userchosen.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.timestamp_machine_steamguard_enabled {
            os.write_fixed32(3, v)?;
        }
        if let Some(v) = self.authentication_exists_from_geoloc_before_mintime {
            os.write_bool(4, v)?;
        }
        for v in &self.newauthentication {
            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(v) = self.authentication_exists_from_same_ip_before_mintime {
            os.write_bool(6, v)?;
        }
        if let Some(v) = self.public_ipv4 {
            os.write_uint32(7, v)?;
        }
        if let Some(ref v) = self.public_ip_address.as_ref() {
            os.write_string(8, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "machine_id",
                |m: &CCredentials_GetSteamGuardDetails_Response_SessionData| { &m.machine_id },
                |m: &mut CCredentials_GetSteamGuardDetails_Response_SessionData| { &mut m.machine_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "machine_name_userchosen",
                |m: &CCredentials_GetSteamGuardDetails_Response_SessionData| { &m.machine_name_userchosen },
                |m: &mut CCredentials_GetSteamGuardDetails_Response_SessionData| { &mut m.machine_name_userchosen },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "timestamp_machine_steamguard_enabled",
                |m: &CCredentials_GetSteamGuardDetails_Response_SessionData| { &m.timestamp_machine_steamguard_enabled },
                |m: &mut CCredentials_GetSteamGuardDetails_Response_SessionData| { &mut m.timestamp_machine_steamguard_enabled },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "authentication_exists_from_geoloc_before_mintime",
                |m: &CCredentials_GetSteamGuardDetails_Response_SessionData| { &m.authentication_exists_from_geoloc_before_mintime },
                |m: &mut CCredentials_GetSteamGuardDetails_Response_SessionData| { &mut m.authentication_exists_from_geoloc_before_mintime },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CCredentials_GetSteamGuardDetails_Response_NewAuthentication>>(
                "newauthentication",
                |m: &CCredentials_GetSteamGuardDetails_Response_SessionData| { &m.newauthentication },
                |m: &mut CCredentials_GetSteamGuardDetails_Response_SessionData| { &mut m.newauthentication },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "authentication_exists_from_same_ip_before_mintime",
                |m: &CCredentials_GetSteamGuardDetails_Response_SessionData| { &m.authentication_exists_from_same_ip_before_mintime },
                |m: &mut CCredentials_GetSteamGuardDetails_Response_SessionData| { &mut m.authentication_exists_from_same_ip_before_mintime },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "public_ipv4",
                |m: &CCredentials_GetSteamGuardDetails_Response_SessionData| { &m.public_ipv4 },
                |m: &mut CCredentials_GetSteamGuardDetails_Response_SessionData| { &mut m.public_ipv4 },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "public_ip_address",
                |m: &CCredentials_GetSteamGuardDetails_Response_SessionData| { &m.public_ip_address },
                |m: &mut CCredentials_GetSteamGuardDetails_Response_SessionData| { &mut m.public_ip_address },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_GetSteamGuardDetails_Response_SessionData>(
                "CCredentials_GetSteamGuardDetails_Response.SessionData",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CCredentials_GetSteamGuardDetails_Response_SessionData {
    fn clear(&mut self) {
        self.machine_id = ::std::option::Option::None;
        self.machine_name_userchosen.clear();
        self.timestamp_machine_steamguard_enabled = ::std::option::Option::None;
        self.authentication_exists_from_geoloc_before_mintime = ::std::option::Option::None;
        self.newauthentication.clear();
        self.authentication_exists_from_same_ip_before_mintime = ::std::option::Option::None;
        self.public_ipv4 = ::std::option::Option::None;
        self.public_ip_address.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional bool is_approved = 1;


    pub fn get_is_approved(&self) -> bool {
        self.is_approved.unwrap_or(false)
    }
    pub fn clear_is_approved(&mut self) {
        self.is_approved = ::std::option::Option::None;
    }

    pub fn has_is_approved(&self) -> bool {
        self.is_approved.is_some()
    }

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

    // optional bool is_wizard_complete = 2;


    pub fn get_is_wizard_complete(&self) -> bool {
        self.is_wizard_complete.unwrap_or(false)
    }
    pub fn clear_is_wizard_complete(&mut self) {
        self.is_wizard_complete = ::std::option::Option::None;
    }

    pub fn has_is_wizard_complete(&self) -> bool {
        self.is_wizard_complete.is_some()
    }

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

impl ::protobuf::Message for CCredentials_NewMachineNotificationDialog_Request {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_approved = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_wizard_complete = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.is_approved {
            my_size += 2;
        }
        if let Some(v) = self.is_wizard_complete {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.is_approved {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.is_wizard_complete {
            os.write_bool(2, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_approved",
                |m: &CCredentials_NewMachineNotificationDialog_Request| { &m.is_approved },
                |m: &mut CCredentials_NewMachineNotificationDialog_Request| { &mut m.is_approved },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_wizard_complete",
                |m: &CCredentials_NewMachineNotificationDialog_Request| { &m.is_wizard_complete },
                |m: &mut CCredentials_NewMachineNotificationDialog_Request| { &mut m.is_wizard_complete },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_NewMachineNotificationDialog_Request>(
                "CCredentials_NewMachineNotificationDialog_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

impl ::protobuf::Message for CCredentials_NewMachineNotificationDialog_Response {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let fields = ::std::vec::Vec::new();
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_NewMachineNotificationDialog_Response>(
                "CCredentials_NewMachineNotificationDialog_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional string stoken = 1;


    pub fn get_stoken(&self) -> &str {
        match self.stoken.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_stoken(&mut self) {
        self.stoken.clear();
    }

    pub fn has_stoken(&self) -> bool {
        self.stoken.is_some()
    }

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

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

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

impl ::protobuf::Message for CCredentials_ValidateEmailAddress_Request {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.stoken)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.stoken.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.stoken.as_ref() {
            os.write_string(1, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "stoken",
                |m: &CCredentials_ValidateEmailAddress_Request| { &m.stoken },
                |m: &mut CCredentials_ValidateEmailAddress_Request| { &mut m.stoken },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_ValidateEmailAddress_Request>(
                "CCredentials_ValidateEmailAddress_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional bool was_validated = 1;


    pub fn get_was_validated(&self) -> bool {
        self.was_validated.unwrap_or(false)
    }
    pub fn clear_was_validated(&mut self) {
        self.was_validated = ::std::option::Option::None;
    }

    pub fn has_was_validated(&self) -> bool {
        self.was_validated.is_some()
    }

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

impl ::protobuf::Message for CCredentials_ValidateEmailAddress_Response {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.was_validated = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.was_validated {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.was_validated {
            os.write_bool(1, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "was_validated",
                |m: &CCredentials_ValidateEmailAddress_Response| { &m.was_validated },
                |m: &mut CCredentials_ValidateEmailAddress_Response| { &mut m.was_validated },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_ValidateEmailAddress_Response>(
                "CCredentials_ValidateEmailAddress_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional string param_string = 1;


    pub fn get_param_string(&self) -> &str {
        match self.param_string.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_param_string(&mut self) {
        self.param_string.clear();
    }

    pub fn has_param_string(&self) -> bool {
        self.param_string.is_some()
    }

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

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

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

    // optional string ipaddress_actual = 2;


    pub fn get_ipaddress_actual(&self) -> &str {
        match self.ipaddress_actual.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_ipaddress_actual(&mut self) {
        self.ipaddress_actual.clear();
    }

    pub fn has_ipaddress_actual(&self) -> bool {
        self.ipaddress_actual.is_some()
    }

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

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

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

impl ::protobuf::Message for CCredentials_SteamGuardPhishingReport_Request {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.param_string)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.ipaddress_actual)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.param_string.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.ipaddress_actual.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.param_string.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.ipaddress_actual.as_ref() {
            os.write_string(2, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "param_string",
                |m: &CCredentials_SteamGuardPhishingReport_Request| { &m.param_string },
                |m: &mut CCredentials_SteamGuardPhishingReport_Request| { &mut m.param_string },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "ipaddress_actual",
                |m: &CCredentials_SteamGuardPhishingReport_Request| { &m.ipaddress_actual },
                |m: &mut CCredentials_SteamGuardPhishingReport_Request| { &mut m.ipaddress_actual },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_SteamGuardPhishingReport_Request>(
                "CCredentials_SteamGuardPhishingReport_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CCredentials_SteamGuardPhishingReport_Response {
    // message fields
    ipaddress_loginattempt: ::protobuf::SingularField<::std::string::String>,
    countryname_loginattempt: ::protobuf::SingularField<::std::string::String>,
    statename_loginattempt: ::protobuf::SingularField<::std::string::String>,
    cityname_loginattempt: ::protobuf::SingularField<::std::string::String>,
    ipaddress_actual: ::protobuf::SingularField<::std::string::String>,
    countryname_actual: ::protobuf::SingularField<::std::string::String>,
    statename_actual: ::protobuf::SingularField<::std::string::String>,
    cityname_actual: ::protobuf::SingularField<::std::string::String>,
    steamguard_code: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string ipaddress_loginattempt = 1;


    pub fn get_ipaddress_loginattempt(&self) -> &str {
        match self.ipaddress_loginattempt.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_ipaddress_loginattempt(&mut self) {
        self.ipaddress_loginattempt.clear();
    }

    pub fn has_ipaddress_loginattempt(&self) -> bool {
        self.ipaddress_loginattempt.is_some()
    }

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

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

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

    // optional string countryname_loginattempt = 2;


    pub fn get_countryname_loginattempt(&self) -> &str {
        match self.countryname_loginattempt.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_countryname_loginattempt(&mut self) {
        self.countryname_loginattempt.clear();
    }

    pub fn has_countryname_loginattempt(&self) -> bool {
        self.countryname_loginattempt.is_some()
    }

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

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

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

    // optional string statename_loginattempt = 3;


    pub fn get_statename_loginattempt(&self) -> &str {
        match self.statename_loginattempt.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_statename_loginattempt(&mut self) {
        self.statename_loginattempt.clear();
    }

    pub fn has_statename_loginattempt(&self) -> bool {
        self.statename_loginattempt.is_some()
    }

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

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

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

    // optional string cityname_loginattempt = 4;


    pub fn get_cityname_loginattempt(&self) -> &str {
        match self.cityname_loginattempt.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_cityname_loginattempt(&mut self) {
        self.cityname_loginattempt.clear();
    }

    pub fn has_cityname_loginattempt(&self) -> bool {
        self.cityname_loginattempt.is_some()
    }

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

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

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

    // optional string ipaddress_actual = 5;


    pub fn get_ipaddress_actual(&self) -> &str {
        match self.ipaddress_actual.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_ipaddress_actual(&mut self) {
        self.ipaddress_actual.clear();
    }

    pub fn has_ipaddress_actual(&self) -> bool {
        self.ipaddress_actual.is_some()
    }

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

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

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

    // optional string countryname_actual = 6;


    pub fn get_countryname_actual(&self) -> &str {
        match self.countryname_actual.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_countryname_actual(&mut self) {
        self.countryname_actual.clear();
    }

    pub fn has_countryname_actual(&self) -> bool {
        self.countryname_actual.is_some()
    }

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

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

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

    // optional string statename_actual = 7;


    pub fn get_statename_actual(&self) -> &str {
        match self.statename_actual.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_statename_actual(&mut self) {
        self.statename_actual.clear();
    }

    pub fn has_statename_actual(&self) -> bool {
        self.statename_actual.is_some()
    }

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

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

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

    // optional string cityname_actual = 8;


    pub fn get_cityname_actual(&self) -> &str {
        match self.cityname_actual.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_cityname_actual(&mut self) {
        self.cityname_actual.clear();
    }

    pub fn has_cityname_actual(&self) -> bool {
        self.cityname_actual.is_some()
    }

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

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

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

    // optional string steamguard_code = 9;


    pub fn get_steamguard_code(&self) -> &str {
        match self.steamguard_code.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_steamguard_code(&mut self) {
        self.steamguard_code.clear();
    }

    pub fn has_steamguard_code(&self) -> bool {
        self.steamguard_code.is_some()
    }

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

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

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

impl ::protobuf::Message for CCredentials_SteamGuardPhishingReport_Response {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.ipaddress_loginattempt)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.countryname_loginattempt)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.statename_loginattempt)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.cityname_loginattempt)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.ipaddress_actual)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.countryname_actual)?;
                },
                7 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.statename_actual)?;
                },
                8 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.cityname_actual)?;
                },
                9 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.steamguard_code)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.ipaddress_loginattempt.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.countryname_loginattempt.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(ref v) = self.statename_loginattempt.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(ref v) = self.cityname_loginattempt.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        if let Some(ref v) = self.ipaddress_actual.as_ref() {
            my_size += ::protobuf::rt::string_size(5, &v);
        }
        if let Some(ref v) = self.countryname_actual.as_ref() {
            my_size += ::protobuf::rt::string_size(6, &v);
        }
        if let Some(ref v) = self.statename_actual.as_ref() {
            my_size += ::protobuf::rt::string_size(7, &v);
        }
        if let Some(ref v) = self.cityname_actual.as_ref() {
            my_size += ::protobuf::rt::string_size(8, &v);
        }
        if let Some(ref v) = self.steamguard_code.as_ref() {
            my_size += ::protobuf::rt::string_size(9, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.ipaddress_loginattempt.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.countryname_loginattempt.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(ref v) = self.statename_loginattempt.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(ref v) = self.cityname_loginattempt.as_ref() {
            os.write_string(4, &v)?;
        }
        if let Some(ref v) = self.ipaddress_actual.as_ref() {
            os.write_string(5, &v)?;
        }
        if let Some(ref v) = self.countryname_actual.as_ref() {
            os.write_string(6, &v)?;
        }
        if let Some(ref v) = self.statename_actual.as_ref() {
            os.write_string(7, &v)?;
        }
        if let Some(ref v) = self.cityname_actual.as_ref() {
            os.write_string(8, &v)?;
        }
        if let Some(ref v) = self.steamguard_code.as_ref() {
            os.write_string(9, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "ipaddress_loginattempt",
                |m: &CCredentials_SteamGuardPhishingReport_Response| { &m.ipaddress_loginattempt },
                |m: &mut CCredentials_SteamGuardPhishingReport_Response| { &mut m.ipaddress_loginattempt },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "countryname_loginattempt",
                |m: &CCredentials_SteamGuardPhishingReport_Response| { &m.countryname_loginattempt },
                |m: &mut CCredentials_SteamGuardPhishingReport_Response| { &mut m.countryname_loginattempt },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "statename_loginattempt",
                |m: &CCredentials_SteamGuardPhishingReport_Response| { &m.statename_loginattempt },
                |m: &mut CCredentials_SteamGuardPhishingReport_Response| { &mut m.statename_loginattempt },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "cityname_loginattempt",
                |m: &CCredentials_SteamGuardPhishingReport_Response| { &m.cityname_loginattempt },
                |m: &mut CCredentials_SteamGuardPhishingReport_Response| { &mut m.cityname_loginattempt },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "ipaddress_actual",
                |m: &CCredentials_SteamGuardPhishingReport_Response| { &m.ipaddress_actual },
                |m: &mut CCredentials_SteamGuardPhishingReport_Response| { &mut m.ipaddress_actual },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "countryname_actual",
                |m: &CCredentials_SteamGuardPhishingReport_Response| { &m.countryname_actual },
                |m: &mut CCredentials_SteamGuardPhishingReport_Response| { &mut m.countryname_actual },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "statename_actual",
                |m: &CCredentials_SteamGuardPhishingReport_Response| { &m.statename_actual },
                |m: &mut CCredentials_SteamGuardPhishingReport_Response| { &mut m.statename_actual },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "cityname_actual",
                |m: &CCredentials_SteamGuardPhishingReport_Response| { &m.cityname_actual },
                |m: &mut CCredentials_SteamGuardPhishingReport_Response| { &mut m.cityname_actual },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "steamguard_code",
                |m: &CCredentials_SteamGuardPhishingReport_Response| { &m.steamguard_code },
                |m: &mut CCredentials_SteamGuardPhishingReport_Response| { &mut m.steamguard_code },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_SteamGuardPhishingReport_Response>(
                "CCredentials_SteamGuardPhishingReport_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CCredentials_SteamGuardPhishingReport_Response {
    fn clear(&mut self) {
        self.ipaddress_loginattempt.clear();
        self.countryname_loginattempt.clear();
        self.statename_loginattempt.clear();
        self.cityname_loginattempt.clear();
        self.ipaddress_actual.clear();
        self.countryname_actual.clear();
        self.statename_actual.clear();
        self.cityname_actual.clear();
        self.steamguard_code.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional bool user_changes_only = 1;


    pub fn get_user_changes_only(&self) -> bool {
        self.user_changes_only.unwrap_or(false)
    }
    pub fn clear_user_changes_only(&mut self) {
        self.user_changes_only = ::std::option::Option::None;
    }

    pub fn has_user_changes_only(&self) -> bool {
        self.user_changes_only.is_some()
    }

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

impl ::protobuf::Message for CCredentials_LastCredentialChangeTime_Request {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.user_changes_only = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.user_changes_only {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.user_changes_only {
            os.write_bool(1, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "user_changes_only",
                |m: &CCredentials_LastCredentialChangeTime_Request| { &m.user_changes_only },
                |m: &mut CCredentials_LastCredentialChangeTime_Request| { &mut m.user_changes_only },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_LastCredentialChangeTime_Request>(
                "CCredentials_LastCredentialChangeTime_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CCredentials_LastCredentialChangeTime_Response {
    // message fields
    timestamp_last_password_change: ::std::option::Option<u32>,
    timestamp_last_email_change: ::std::option::Option<u32>,
    timestamp_last_password_reset: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed32 timestamp_last_password_change = 1;


    pub fn get_timestamp_last_password_change(&self) -> u32 {
        self.timestamp_last_password_change.unwrap_or(0)
    }
    pub fn clear_timestamp_last_password_change(&mut self) {
        self.timestamp_last_password_change = ::std::option::Option::None;
    }

    pub fn has_timestamp_last_password_change(&self) -> bool {
        self.timestamp_last_password_change.is_some()
    }

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

    // optional fixed32 timestamp_last_email_change = 2;


    pub fn get_timestamp_last_email_change(&self) -> u32 {
        self.timestamp_last_email_change.unwrap_or(0)
    }
    pub fn clear_timestamp_last_email_change(&mut self) {
        self.timestamp_last_email_change = ::std::option::Option::None;
    }

    pub fn has_timestamp_last_email_change(&self) -> bool {
        self.timestamp_last_email_change.is_some()
    }

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

    // optional fixed32 timestamp_last_password_reset = 3;


    pub fn get_timestamp_last_password_reset(&self) -> u32 {
        self.timestamp_last_password_reset.unwrap_or(0)
    }
    pub fn clear_timestamp_last_password_reset(&mut self) {
        self.timestamp_last_password_reset = ::std::option::Option::None;
    }

    pub fn has_timestamp_last_password_reset(&self) -> bool {
        self.timestamp_last_password_reset.is_some()
    }

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

impl ::protobuf::Message for CCredentials_LastCredentialChangeTime_Response {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.timestamp_last_password_change = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.timestamp_last_email_change = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.timestamp_last_password_reset = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.timestamp_last_password_change {
            my_size += 5;
        }
        if let Some(v) = self.timestamp_last_email_change {
            my_size += 5;
        }
        if let Some(v) = self.timestamp_last_password_reset {
            my_size += 5;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.timestamp_last_password_change {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.timestamp_last_email_change {
            os.write_fixed32(2, v)?;
        }
        if let Some(v) = self.timestamp_last_password_reset {
            os.write_fixed32(3, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "timestamp_last_password_change",
                |m: &CCredentials_LastCredentialChangeTime_Response| { &m.timestamp_last_password_change },
                |m: &mut CCredentials_LastCredentialChangeTime_Response| { &mut m.timestamp_last_password_change },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "timestamp_last_email_change",
                |m: &CCredentials_LastCredentialChangeTime_Response| { &m.timestamp_last_email_change },
                |m: &mut CCredentials_LastCredentialChangeTime_Response| { &mut m.timestamp_last_email_change },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "timestamp_last_password_reset",
                |m: &CCredentials_LastCredentialChangeTime_Response| { &m.timestamp_last_password_reset },
                |m: &mut CCredentials_LastCredentialChangeTime_Response| { &mut m.timestamp_last_password_reset },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_LastCredentialChangeTime_Response>(
                "CCredentials_LastCredentialChangeTime_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CCredentials_LastCredentialChangeTime_Response {
    fn clear(&mut self) {
        self.timestamp_last_password_change = ::std::option::Option::None;
        self.timestamp_last_email_change = ::std::option::Option::None;
        self.timestamp_last_password_reset = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

impl ::protobuf::Message for CCredentials_GetAccountAuthSecret_Request {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let fields = ::std::vec::Vec::new();
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_GetAccountAuthSecret_Request>(
                "CCredentials_GetAccountAuthSecret_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CCredentials_GetAccountAuthSecret_Response {
    // message fields
    secret_id: ::std::option::Option<i32>,
    secret: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional int32 secret_id = 1;


    pub fn get_secret_id(&self) -> i32 {
        self.secret_id.unwrap_or(0)
    }
    pub fn clear_secret_id(&mut self) {
        self.secret_id = ::std::option::Option::None;
    }

    pub fn has_secret_id(&self) -> bool {
        self.secret_id.is_some()
    }

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

    // optional bytes secret = 2;


    pub fn get_secret(&self) -> &[u8] {
        match self.secret.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_secret(&mut self) {
        self.secret.clear();
    }

    pub fn has_secret(&self) -> bool {
        self.secret.is_some()
    }

    // Param is passed by value, moved
    pub fn set_secret(&mut self, v: ::std::vec::Vec<u8>) {
        self.secret = ::protobuf::SingularField::some(v);
    }

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

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

impl ::protobuf::Message for CCredentials_GetAccountAuthSecret_Response {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.secret_id = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.secret)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.secret_id {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.secret.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.secret_id {
            os.write_int32(1, v)?;
        }
        if let Some(ref v) = self.secret.as_ref() {
            os.write_bytes(2, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "secret_id",
                |m: &CCredentials_GetAccountAuthSecret_Response| { &m.secret_id },
                |m: &mut CCredentials_GetAccountAuthSecret_Response| { &mut m.secret_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "secret",
                |m: &CCredentials_GetAccountAuthSecret_Response| { &m.secret },
                |m: &mut CCredentials_GetAccountAuthSecret_Response| { &mut m.secret },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CCredentials_GetAccountAuthSecret_Response>(
                "CCredentials_GetAccountAuthSecret_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n+steammessages_credentials.steamclient.proto\x1a,steammessages_unified\
    _base.steamclient.proto\"\x9b\x01\n*CCredentials_TestAvailablePassword_R\
    equest\x12\x1a\n\x08password\x18\x01\x20\x01(\tR\x08password\x12.\n\x13s\
    ha_digest_password\x18\x02\x20\x01(\x0cR\x11shaDigestPassword\x12!\n\x0c\
    account_name\x18\x03\x20\x01(\tR\x0baccountName\"H\n+CCredentials_TestAv\
    ailablePassword_Response\x12\x19\n\x08is_valid\x18\x03\x20\x01(\x08R\x07\
    isValid\"\xb9\x03\n)CCredentials_GetSteamGuardDetails_Request\x12\x90\
    \x01\n\x1binclude_new_authentications\x18\x01\x20\x01(\x08:\x04trueR\x19\
    includeNewAuthenticationsBJ\x82\xb5\x18FWhether\x20or\x20not\x20to\x20po\
    pulate\x20the\x20newauthentication\x20field\x20in\x20the\x20response\x12\
    \xa0\x01\n\twebcookie\x18\x02\x20\x01(\tR\twebcookieB\x81\x01\x82\xb5\
    \x18}The\x20user's\x20Steam\x20Guard\x20machine\x20auth\x20cookie.\x20If\
    \x20present,\x20it'll\x20be\x20used\x20to\x20get\x20the\x20user's\x20mac\
    hine\x20ID\x20instead\x20of\x20the\x20AM\x20session.\x128\n\x18timestamp\
    _minimum_wanted\x18\x03\x20\x01(\x07R\x16timestampMinimumWanted\x12\x1c\
    \n\tipaddress\x18\x04\x20\x01(\x05R\tipaddress\"\xf8\r\n*CCredentials_Ge\
    tSteamGuardDetails_Response\x122\n\x15is_steamguard_enabled\x18\x01\x20\
    \x01(\x08R\x13isSteamguardEnabled\x12@\n\x1ctimestamp_steamguard_enabled\
    \x18\x02\x20\x01(\x07R\x1atimestampSteamguardEnabled\x12\x80\x01\n\x1cde\
    precated_newauthentication\x18\x03\x20\x03(\x0b2=.CCredentials_GetSteamG\
    uardDetails_Response.NewAuthenticationR\x1bdeprecatedNewauthentication\
    \x12K\n\"deprecated_machine_name_userchosen\x18\x04\x20\x01(\tR\x1fdepre\
    catedMachineNameUserchosen\x12d\n/deprecated_timestamp_machine_steamguar\
    d_enabled\x18\x05\x20\x01(\x07R+deprecatedTimestampMachineSteamguardEnab\
    led\x12z\n;deprecated_authentication_exists_from_geoloc_before_mintime\
    \x18\x06\x20\x01(\x08R5deprecatedAuthenticationExistsFromGeolocBeforeMin\
    time\x122\n\x15deprecated_machine_id\x18\x07\x20\x01(\x04R\x13deprecated\
    MachineId\x12Z\n\x0csession_data\x18\x08\x20\x03(\x0b27.CCredentials_Get\
    SteamGuardDetails_Response.SessionDataR\x0bsessionData\x120\n\x14is_twof\
    actor_enabled\x18\t\x20\x01(\x08R\x12isTwofactorEnabled\x12>\n\x1btimest\
    amp_twofactor_enabled\x18\n\x20\x01(\x07R\x19timestampTwofactorEnabled\
    \x12*\n\x11is_phone_verified\x18\x0b\x20\x01(\x08R\x0fisPhoneVerified\
    \x1a\xb2\x02\n\x11NewAuthentication\x12@\n\x1ctimestamp_steamguard_enabl\
    ed\x18\x01\x20\x01(\x07R\x1atimestampSteamguardEnabled\x12\"\n\ris_web_c\
    ookie\x18\x02\x20\x01(\x08R\x0bisWebCookie\x12\x1c\n\tipaddress\x18\x03\
    \x20\x01(\x05R\tipaddress\x12\x1f\n\x0bgeoloc_info\x18\x04\x20\x01(\tR\n\
    geolocInfo\x12#\n\ris_remembered\x18\x05\x20\x01(\x08R\x0cisRemembered\
    \x12;\n\x1amachine_name_user_supplied\x18\x06\x20\x01(\tR\x17machineName\
    UserSupplied\x12\x16\n\x06status\x18\x07\x20\x01(\x05R\x06status\x1a\xbe\
    \x04\n\x0bSessionData\x12\x1d\n\nmachine_id\x18\x01\x20\x01(\x04R\tmachi\
    neId\x126\n\x17machine_name_userchosen\x18\x02\x20\x01(\tR\x15machineNam\
    eUserchosen\x12O\n$timestamp_machine_steamguard_enabled\x18\x03\x20\x01(\
    \x07R!timestampMachineSteamguardEnabled\x12e\n0authentication_exists_fro\
    m_geoloc_before_mintime\x18\x04\x20\x01(\x08R+authenticationExistsFromGe\
    olocBeforeMintime\x12k\n\x11newauthentication\x18\x05\x20\x03(\x0b2=.CCr\
    edentials_GetSteamGuardDetails_Response.NewAuthenticationR\x11newauthent\
    ication\x12f\n1authentication_exists_from_same_ip_before_mintime\x18\x06\
    \x20\x01(\x08R+authenticationExistsFromSameIpBeforeMintime\x12\x1f\n\x0b\
    public_ipv4\x18\x07\x20\x01(\rR\npublicIpv4\x12*\n\x11public_ip_address\
    \x18\x08\x20\x01(\tR\x0fpublicIpAddress\"\x82\x01\n1CCredentials_NewMach\
    ineNotificationDialog_Request\x12\x1f\n\x0bis_approved\x18\x01\x20\x01(\
    \x08R\nisApproved\x12,\n\x12is_wizard_complete\x18\x02\x20\x01(\x08R\x10\
    isWizardComplete\"4\n2CCredentials_NewMachineNotificationDialog_Response\
    \"C\n)CCredentials_ValidateEmailAddress_Request\x12\x16\n\x06stoken\x18\
    \x01\x20\x01(\tR\x06stoken\"Q\n*CCredentials_ValidateEmailAddress_Respon\
    se\x12#\n\rwas_validated\x18\x01\x20\x01(\x08R\x0cwasValidated\"}\n-CCre\
    dentials_SteamGuardPhishingReport_Request\x12!\n\x0cparam_string\x18\x01\
    \x20\x01(\tR\x0bparamString\x12)\n\x10ipaddress_actual\x18\x02\x20\x01(\
    \tR\x0fipaddressActual\"\xe5\x03\n.CCredentials_SteamGuardPhishingReport\
    _Response\x125\n\x16ipaddress_loginattempt\x18\x01\x20\x01(\tR\x15ipaddr\
    essLoginattempt\x129\n\x18countryname_loginattempt\x18\x02\x20\x01(\tR\
    \x17countrynameLoginattempt\x125\n\x16statename_loginattempt\x18\x03\x20\
    \x01(\tR\x15statenameLoginattempt\x123\n\x15cityname_loginattempt\x18\
    \x04\x20\x01(\tR\x14citynameLoginattempt\x12)\n\x10ipaddress_actual\x18\
    \x05\x20\x01(\tR\x0fipaddressActual\x12-\n\x12countryname_actual\x18\x06\
    \x20\x01(\tR\x11countrynameActual\x12)\n\x10statename_actual\x18\x07\x20\
    \x01(\tR\x0fstatenameActual\x12'\n\x0fcityname_actual\x18\x08\x20\x01(\t\
    R\x0ecitynameActual\x12'\n\x0fsteamguard_code\x18\t\x20\x01(\tR\x0esteam\
    guardCode\"[\n-CCredentials_LastCredentialChangeTime_Request\x12*\n\x11u\
    ser_changes_only\x18\x01\x20\x01(\x08R\x0fuserChangesOnly\"\xf7\x01\n.CC\
    redentials_LastCredentialChangeTime_Response\x12C\n\x1etimestamp_last_pa\
    ssword_change\x18\x01\x20\x01(\x07R\x1btimestampLastPasswordChange\x12=\
    \n\x1btimestamp_last_email_change\x18\x02\x20\x01(\x07R\x18timestampLast\
    EmailChange\x12A\n\x1dtimestamp_last_password_reset\x18\x03\x20\x01(\x07\
    R\x1atimestampLastPasswordReset\"+\n)CCredentials_GetAccountAuthSecret_R\
    equest\"a\n*CCredentials_GetAccountAuthSecret_Response\x12\x1b\n\tsecret\
    _id\x18\x01\x20\x01(\x05R\x08secretId\x12\x16\n\x06secret\x18\x02\x20\
    \x01(\x0cR\x06secret2\xed\x08\n\x0bCredentials\x12\x8e\x01\n\x15TestAvai\
    lablePassword\x12+.CCredentials_TestAvailablePassword_Request\x1a,.CCred\
    entials_TestAvailablePassword_Response\"\x1a\x82\xb5\x18\x16TestAvailabl\
    ePassword.\x12\x8a\x01\n\x14GetSteamGuardDetails\x12*.CCredentials_GetSt\
    eamGuardDetails_Request\x1a+.CCredentials_GetSteamGuardDetails_Response\
    \"\x19\x82\xb5\x18\x15GetSteamGuardDetails.\x12\xb6\x01\n\"NewMachineNot\
    ificationDialogResult\x122.CCredentials_NewMachineNotificationDialog_Req\
    uest\x1a3.CCredentials_NewMachineNotificationDialog_Response\"'\x82\xb5\
    \x18#NewMachineNotificationDialogResult.\x12\x9c\x01\n\x14ValidateEmailA\
    ddress\x12*.CCredentials_ValidateEmailAddress_Request\x1a+.CCredentials_\
    ValidateEmailAddress_Response\"+\x82\xb5\x18'Validate\x20an\x20email\x20\
    address\x20given\x20a\x20token\x12\x99\x01\n\x18SteamGuardPhishingReport\
    \x12..CCredentials_SteamGuardPhishingReport_Request\x1a/.CCredentials_St\
    eamGuardPhishingReport_Response\"\x1c\x82\xb5\x18\x18SteamGuardPhishingR\
    eport\x12\xa6\x01\n\x1eGetCredentialChangeTimeDetails\x12..CCredentials_\
    LastCredentialChangeTime_Request\x1a/.CCredentials_LastCredentialChangeT\
    ime_Response\"#\x82\xb5\x18\x1fGetCredentialChangeTimeDetails.\x12\x89\
    \x01\n\x14GetAccountAuthSecret\x12*.CCredentials_GetAccountAuthSecret_Re\
    quest\x1a+.CCredentials_GetAccountAuthSecret_Response\"\x18\x82\xb5\x18\
    \x14GetAccountAuthSecret\x1a\x17\x82\xb5\x18\x13Credentials\x20serviceB\
    \x03\x80\x01\x01J\x97(\n\x07\x12\x05\0\0\x89\x01\x01\n\t\n\x02\x03\0\x12\
    \x03\0\06\n\x08\n\x01\x08\x12\x03\x02\0\"\n\t\n\x02\x08\x10\x12\x03\x02\
    \0\"\n\n\n\x02\x04\0\x12\x04\x04\0\x08\x01\n\n\n\x03\x04\0\x01\x12\x03\
    \x04\x082\n\x0b\n\x04\x04\0\x02\0\x12\x03\x05\x08%\n\x0c\n\x05\x04\0\x02\
    \0\x04\x12\x03\x05\x08\x10\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x05\x11\
    \x17\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x05\x18\x20\n\x0c\n\x05\x04\0\
    \x02\0\x03\x12\x03\x05#$\n\x0b\n\x04\x04\0\x02\x01\x12\x03\x06\x08/\n\
    \x0c\n\x05\x04\0\x02\x01\x04\x12\x03\x06\x08\x10\n\x0c\n\x05\x04\0\x02\
    \x01\x05\x12\x03\x06\x11\x16\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\x06\
    \x17*\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03\x06-.\n\x0b\n\x04\x04\0\x02\
    \x02\x12\x03\x07\x08)\n\x0c\n\x05\x04\0\x02\x02\x04\x12\x03\x07\x08\x10\
    \n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03\x07\x11\x17\n\x0c\n\x05\x04\0\x02\
    \x02\x01\x12\x03\x07\x18$\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03\x07'(\n\
    \n\n\x02\x04\x01\x12\x04\n\0\x0c\x01\n\n\n\x03\x04\x01\x01\x12\x03\n\x08\
    3\n\x0b\n\x04\x04\x01\x02\0\x12\x03\x0b\x08#\n\x0c\n\x05\x04\x01\x02\0\
    \x04\x12\x03\x0b\x08\x10\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03\x0b\x11\
    \x15\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\x0b\x16\x1e\n\x0c\n\x05\x04\
    \x01\x02\0\x03\x12\x03\x0b!\"\n\n\n\x02\x04\x02\x12\x04\x0e\0\x13\x01\n\
    \n\n\x03\x04\x02\x01\x12\x03\x0e\x081\n\x0c\n\x04\x04\x02\x02\0\x12\x04\
    \x0f\x08\xa1\x01\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03\x0f\x08\x10\n\x0c\
    \n\x05\x04\x02\x02\0\x05\x12\x03\x0f\x11\x15\n\x0c\n\x05\x04\x02\x02\0\
    \x01\x12\x03\x0f\x161\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03\x0f45\n\r\n\
    \x05\x04\x02\x02\0\x08\x12\x04\x0f6\xa0\x01\n\x0c\n\x05\x04\x02\x02\0\
    \x07\x12\x03\x0fAE\n\x10\n\x08\x04\x02\x02\0\x08\xd0\x86\x03\x12\x04\x0f\
    G\x9f\x01\n\x0c\n\x04\x04\x02\x02\x01\x12\x04\x10\x08\xb8\x01\n\x0c\n\
    \x05\x04\x02\x02\x01\x04\x12\x03\x10\x08\x10\n\x0c\n\x05\x04\x02\x02\x01\
    \x05\x12\x03\x10\x11\x17\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03\x10\x18\
    !\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03\x10$%\n\r\n\x05\x04\x02\x02\
    \x01\x08\x12\x04\x10&\xb7\x01\n\x10\n\x08\x04\x02\x02\x01\x08\xd0\x86\
    \x03\x12\x04\x10'\xb6\x01\n\x0b\n\x04\x04\x02\x02\x02\x12\x03\x11\x086\n\
    \x0c\n\x05\x04\x02\x02\x02\x04\x12\x03\x11\x08\x10\n\x0c\n\x05\x04\x02\
    \x02\x02\x05\x12\x03\x11\x11\x18\n\x0c\n\x05\x04\x02\x02\x02\x01\x12\x03\
    \x11\x191\n\x0c\n\x05\x04\x02\x02\x02\x03\x12\x03\x1145\n\x0b\n\x04\x04\
    \x02\x02\x03\x12\x03\x12\x08%\n\x0c\n\x05\x04\x02\x02\x03\x04\x12\x03\
    \x12\x08\x10\n\x0c\n\x05\x04\x02\x02\x03\x05\x12\x03\x12\x11\x16\n\x0c\n\
    \x05\x04\x02\x02\x03\x01\x12\x03\x12\x17\x20\n\x0c\n\x05\x04\x02\x02\x03\
    \x03\x12\x03\x12#$\n\n\n\x02\x04\x03\x12\x04\x15\06\x01\n\n\n\x03\x04\
    \x03\x01\x12\x03\x15\x082\n\x0c\n\x04\x04\x03\x03\0\x12\x04\x16\x08\x1e\
    \t\n\x0c\n\x05\x04\x03\x03\0\x01\x12\x03\x16\x10!\n\r\n\x06\x04\x03\x03\
    \0\x02\0\x12\x03\x17\x10B\n\x0e\n\x07\x04\x03\x03\0\x02\0\x04\x12\x03\
    \x17\x10\x18\n\x0e\n\x07\x04\x03\x03\0\x02\0\x05\x12\x03\x17\x19\x20\n\
    \x0e\n\x07\x04\x03\x03\0\x02\0\x01\x12\x03\x17!=\n\x0e\n\x07\x04\x03\x03\
    \0\x02\0\x03\x12\x03\x17@A\n\r\n\x06\x04\x03\x03\0\x02\x01\x12\x03\x18\
    \x100\n\x0e\n\x07\x04\x03\x03\0\x02\x01\x04\x12\x03\x18\x10\x18\n\x0e\n\
    \x07\x04\x03\x03\0\x02\x01\x05\x12\x03\x18\x19\x1d\n\x0e\n\x07\x04\x03\
    \x03\0\x02\x01\x01\x12\x03\x18\x1e+\n\x0e\n\x07\x04\x03\x03\0\x02\x01\
    \x03\x12\x03\x18./\n\r\n\x06\x04\x03\x03\0\x02\x02\x12\x03\x19\x10-\n\
    \x0e\n\x07\x04\x03\x03\0\x02\x02\x04\x12\x03\x19\x10\x18\n\x0e\n\x07\x04\
    \x03\x03\0\x02\x02\x05\x12\x03\x19\x19\x1e\n\x0e\n\x07\x04\x03\x03\0\x02\
    \x02\x01\x12\x03\x19\x1f(\n\x0e\n\x07\x04\x03\x03\0\x02\x02\x03\x12\x03\
    \x19+,\n\r\n\x06\x04\x03\x03\0\x02\x03\x12\x03\x1a\x100\n\x0e\n\x07\x04\
    \x03\x03\0\x02\x03\x04\x12\x03\x1a\x10\x18\n\x0e\n\x07\x04\x03\x03\0\x02\
    \x03\x05\x12\x03\x1a\x19\x1f\n\x0e\n\x07\x04\x03\x03\0\x02\x03\x01\x12\
    \x03\x1a\x20+\n\x0e\n\x07\x04\x03\x03\0\x02\x03\x03\x12\x03\x1a./\n\r\n\
    \x06\x04\x03\x03\0\x02\x04\x12\x03\x1b\x100\n\x0e\n\x07\x04\x03\x03\0\
    \x02\x04\x04\x12\x03\x1b\x10\x18\n\x0e\n\x07\x04\x03\x03\0\x02\x04\x05\
    \x12\x03\x1b\x19\x1d\n\x0e\n\x07\x04\x03\x03\0\x02\x04\x01\x12\x03\x1b\
    \x1e+\n\x0e\n\x07\x04\x03\x03\0\x02\x04\x03\x12\x03\x1b./\n\r\n\x06\x04\
    \x03\x03\0\x02\x05\x12\x03\x1c\x10?\n\x0e\n\x07\x04\x03\x03\0\x02\x05\
    \x04\x12\x03\x1c\x10\x18\n\x0e\n\x07\x04\x03\x03\0\x02\x05\x05\x12\x03\
    \x1c\x19\x1f\n\x0e\n\x07\x04\x03\x03\0\x02\x05\x01\x12\x03\x1c\x20:\n\
    \x0e\n\x07\x04\x03\x03\0\x02\x05\x03\x12\x03\x1c=>\n\r\n\x06\x04\x03\x03\
    \0\x02\x06\x12\x03\x1d\x10*\n\x0e\n\x07\x04\x03\x03\0\x02\x06\x04\x12\
    \x03\x1d\x10\x18\n\x0e\n\x07\x04\x03\x03\0\x02\x06\x05\x12\x03\x1d\x19\
    \x1e\n\x0e\n\x07\x04\x03\x03\0\x02\x06\x01\x12\x03\x1d\x1f%\n\x0e\n\x07\
    \x04\x03\x03\0\x02\x06\x03\x12\x03\x1d()\n\x0c\n\x04\x04\x03\x03\x01\x12\
    \x04\x20\x08)\t\n\x0c\n\x05\x04\x03\x03\x01\x01\x12\x03\x20\x10\x1b\n\r\
    \n\x06\x04\x03\x03\x01\x02\0\x12\x03!\x10/\n\x0e\n\x07\x04\x03\x03\x01\
    \x02\0\x04\x12\x03!\x10\x18\n\x0e\n\x07\x04\x03\x03\x01\x02\0\x05\x12\
    \x03!\x19\x1f\n\x0e\n\x07\x04\x03\x03\x01\x02\0\x01\x12\x03!\x20*\n\x0e\
    \n\x07\x04\x03\x03\x01\x02\0\x03\x12\x03!-.\n\r\n\x06\x04\x03\x03\x01\
    \x02\x01\x12\x03\"\x10<\n\x0e\n\x07\x04\x03\x03\x01\x02\x01\x04\x12\x03\
    \"\x10\x18\n\x0e\n\x07\x04\x03\x03\x01\x02\x01\x05\x12\x03\"\x19\x1f\n\
    \x0e\n\x07\x04\x03\x03\x01\x02\x01\x01\x12\x03\"\x207\n\x0e\n\x07\x04\
    \x03\x03\x01\x02\x01\x03\x12\x03\":;\n\r\n\x06\x04\x03\x03\x01\x02\x02\
    \x12\x03#\x10J\n\x0e\n\x07\x04\x03\x03\x01\x02\x02\x04\x12\x03#\x10\x18\
    \n\x0e\n\x07\x04\x03\x03\x01\x02\x02\x05\x12\x03#\x19\x20\n\x0e\n\x07\
    \x04\x03\x03\x01\x02\x02\x01\x12\x03#!E\n\x0e\n\x07\x04\x03\x03\x01\x02\
    \x02\x03\x12\x03#HI\n\r\n\x06\x04\x03\x03\x01\x02\x03\x12\x03$\x10S\n\
    \x0e\n\x07\x04\x03\x03\x01\x02\x03\x04\x12\x03$\x10\x18\n\x0e\n\x07\x04\
    \x03\x03\x01\x02\x03\x05\x12\x03$\x19\x1d\n\x0e\n\x07\x04\x03\x03\x01\
    \x02\x03\x01\x12\x03$\x1eN\n\x0e\n\x07\x04\x03\x03\x01\x02\x03\x03\x12\
    \x03$QR\n\r\n\x06\x04\x03\x03\x01\x02\x04\x12\x03%\x10m\n\x0e\n\x07\x04\
    \x03\x03\x01\x02\x04\x04\x12\x03%\x10\x18\n\x0e\n\x07\x04\x03\x03\x01\
    \x02\x04\x06\x12\x03%\x19V\n\x0e\n\x07\x04\x03\x03\x01\x02\x04\x01\x12\
    \x03%Wh\n\x0e\n\x07\x04\x03\x03\x01\x02\x04\x03\x12\x03%kl\n\r\n\x06\x04\
    \x03\x03\x01\x02\x05\x12\x03&\x10T\n\x0e\n\x07\x04\x03\x03\x01\x02\x05\
    \x04\x12\x03&\x10\x18\n\x0e\n\x07\x04\x03\x03\x01\x02\x05\x05\x12\x03&\
    \x19\x1d\n\x0e\n\x07\x04\x03\x03\x01\x02\x05\x01\x12\x03&\x1eO\n\x0e\n\
    \x07\x04\x03\x03\x01\x02\x05\x03\x12\x03&RS\n\r\n\x06\x04\x03\x03\x01\
    \x02\x06\x12\x03'\x100\n\x0e\n\x07\x04\x03\x03\x01\x02\x06\x04\x12\x03'\
    \x10\x18\n\x0e\n\x07\x04\x03\x03\x01\x02\x06\x05\x12\x03'\x19\x1f\n\x0e\
    \n\x07\x04\x03\x03\x01\x02\x06\x01\x12\x03'\x20+\n\x0e\n\x07\x04\x03\x03\
    \x01\x02\x06\x03\x12\x03'./\n\r\n\x06\x04\x03\x03\x01\x02\x07\x12\x03(\
    \x106\n\x0e\n\x07\x04\x03\x03\x01\x02\x07\x04\x12\x03(\x10\x18\n\x0e\n\
    \x07\x04\x03\x03\x01\x02\x07\x05\x12\x03(\x19\x1f\n\x0e\n\x07\x04\x03\
    \x03\x01\x02\x07\x01\x12\x03(\x201\n\x0e\n\x07\x04\x03\x03\x01\x02\x07\
    \x03\x12\x03(45\n\x0b\n\x04\x04\x03\x02\0\x12\x03+\x080\n\x0c\n\x05\x04\
    \x03\x02\0\x04\x12\x03+\x08\x10\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x03+\
    \x11\x15\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03+\x16+\n\x0c\n\x05\x04\x03\
    \x02\0\x03\x12\x03+./\n\x0b\n\x04\x04\x03\x02\x01\x12\x03,\x08:\n\x0c\n\
    \x05\x04\x03\x02\x01\x04\x12\x03,\x08\x10\n\x0c\n\x05\x04\x03\x02\x01\
    \x05\x12\x03,\x11\x18\n\x0c\n\x05\x04\x03\x02\x01\x01\x12\x03,\x195\n\
    \x0c\n\x05\x04\x03\x02\x01\x03\x12\x03,89\n\x0b\n\x04\x04\x03\x02\x02\
    \x12\x03-\x08p\n\x0c\n\x05\x04\x03\x02\x02\x04\x12\x03-\x08\x10\n\x0c\n\
    \x05\x04\x03\x02\x02\x06\x12\x03-\x11N\n\x0c\n\x05\x04\x03\x02\x02\x01\
    \x12\x03-Ok\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03-no\n\x0b\n\x04\x04\
    \x03\x02\x03\x12\x03.\x08?\n\x0c\n\x05\x04\x03\x02\x03\x04\x12\x03.\x08\
    \x10\n\x0c\n\x05\x04\x03\x02\x03\x05\x12\x03.\x11\x17\n\x0c\n\x05\x04\
    \x03\x02\x03\x01\x12\x03.\x18:\n\x0c\n\x05\x04\x03\x02\x03\x03\x12\x03.=\
    >\n\x0b\n\x04\x04\x03\x02\x04\x12\x03/\x08M\n\x0c\n\x05\x04\x03\x02\x04\
    \x04\x12\x03/\x08\x10\n\x0c\n\x05\x04\x03\x02\x04\x05\x12\x03/\x11\x18\n\
    \x0c\n\x05\x04\x03\x02\x04\x01\x12\x03/\x19H\n\x0c\n\x05\x04\x03\x02\x04\
    \x03\x12\x03/KL\n\x0b\n\x04\x04\x03\x02\x05\x12\x030\x08V\n\x0c\n\x05\
    \x04\x03\x02\x05\x04\x12\x030\x08\x10\n\x0c\n\x05\x04\x03\x02\x05\x05\
    \x12\x030\x11\x15\n\x0c\n\x05\x04\x03\x02\x05\x01\x12\x030\x16Q\n\x0c\n\
    \x05\x04\x03\x02\x05\x03\x12\x030TU\n\x0b\n\x04\x04\x03\x02\x06\x12\x031\
    \x082\n\x0c\n\x05\x04\x03\x02\x06\x04\x12\x031\x08\x10\n\x0c\n\x05\x04\
    \x03\x02\x06\x05\x12\x031\x11\x17\n\x0c\n\x05\x04\x03\x02\x06\x01\x12\
    \x031\x18-\n\x0c\n\x05\x04\x03\x02\x06\x03\x12\x03101\n\x0b\n\x04\x04\
    \x03\x02\x07\x12\x032\x08Z\n\x0c\n\x05\x04\x03\x02\x07\x04\x12\x032\x08\
    \x10\n\x0c\n\x05\x04\x03\x02\x07\x06\x12\x032\x11H\n\x0c\n\x05\x04\x03\
    \x02\x07\x01\x12\x032IU\n\x0c\n\x05\x04\x03\x02\x07\x03\x12\x032XY\n\x0b\
    \n\x04\x04\x03\x02\x08\x12\x033\x08/\n\x0c\n\x05\x04\x03\x02\x08\x04\x12\
    \x033\x08\x10\n\x0c\n\x05\x04\x03\x02\x08\x05\x12\x033\x11\x15\n\x0c\n\
    \x05\x04\x03\x02\x08\x01\x12\x033\x16*\n\x0c\n\x05\x04\x03\x02\x08\x03\
    \x12\x033-.\n\x0b\n\x04\x04\x03\x02\t\x12\x034\x08:\n\x0c\n\x05\x04\x03\
    \x02\t\x04\x12\x034\x08\x10\n\x0c\n\x05\x04\x03\x02\t\x05\x12\x034\x11\
    \x18\n\x0c\n\x05\x04\x03\x02\t\x01\x12\x034\x194\n\x0c\n\x05\x04\x03\x02\
    \t\x03\x12\x03479\n\x0b\n\x04\x04\x03\x02\n\x12\x035\x08-\n\x0c\n\x05\
    \x04\x03\x02\n\x04\x12\x035\x08\x10\n\x0c\n\x05\x04\x03\x02\n\x05\x12\
    \x035\x11\x15\n\x0c\n\x05\x04\x03\x02\n\x01\x12\x035\x16'\n\x0c\n\x05\
    \x04\x03\x02\n\x03\x12\x035*,\n\n\n\x02\x04\x04\x12\x048\0;\x01\n\n\n\
    \x03\x04\x04\x01\x12\x038\x089\n\x0b\n\x04\x04\x04\x02\0\x12\x039\x08&\n\
    \x0c\n\x05\x04\x04\x02\0\x04\x12\x039\x08\x10\n\x0c\n\x05\x04\x04\x02\0\
    \x05\x12\x039\x11\x15\n\x0c\n\x05\x04\x04\x02\0\x01\x12\x039\x16!\n\x0c\
    \n\x05\x04\x04\x02\0\x03\x12\x039$%\n\x0b\n\x04\x04\x04\x02\x01\x12\x03:\
    \x08-\n\x0c\n\x05\x04\x04\x02\x01\x04\x12\x03:\x08\x10\n\x0c\n\x05\x04\
    \x04\x02\x01\x05\x12\x03:\x11\x15\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\
    \x03:\x16(\n\x0c\n\x05\x04\x04\x02\x01\x03\x12\x03:+,\n\n\n\x02\x04\x05\
    \x12\x04=\0>\x01\n\n\n\x03\x04\x05\x01\x12\x03=\x08:\n\n\n\x02\x04\x06\
    \x12\x04@\0B\x01\n\n\n\x03\x04\x06\x01\x12\x03@\x081\n\x0b\n\x04\x04\x06\
    \x02\0\x12\x03A\x08#\n\x0c\n\x05\x04\x06\x02\0\x04\x12\x03A\x08\x10\n\
    \x0c\n\x05\x04\x06\x02\0\x05\x12\x03A\x11\x17\n\x0c\n\x05\x04\x06\x02\0\
    \x01\x12\x03A\x18\x1e\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03A!\"\n\n\n\
    \x02\x04\x07\x12\x04D\0F\x01\n\n\n\x03\x04\x07\x01\x12\x03D\x082\n\x0b\n\
    \x04\x04\x07\x02\0\x12\x03E\x08(\n\x0c\n\x05\x04\x07\x02\0\x04\x12\x03E\
    \x08\x10\n\x0c\n\x05\x04\x07\x02\0\x05\x12\x03E\x11\x15\n\x0c\n\x05\x04\
    \x07\x02\0\x01\x12\x03E\x16#\n\x0c\n\x05\x04\x07\x02\0\x03\x12\x03E&'\n\
    \n\n\x02\x04\x08\x12\x04H\0K\x01\n\n\n\x03\x04\x08\x01\x12\x03H\x085\n\
    \x0b\n\x04\x04\x08\x02\0\x12\x03I\x08)\n\x0c\n\x05\x04\x08\x02\0\x04\x12\
    \x03I\x08\x10\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x03I\x11\x17\n\x0c\n\x05\
    \x04\x08\x02\0\x01\x12\x03I\x18$\n\x0c\n\x05\x04\x08\x02\0\x03\x12\x03I'\
    (\n\x0b\n\x04\x04\x08\x02\x01\x12\x03J\x08-\n\x0c\n\x05\x04\x08\x02\x01\
    \x04\x12\x03J\x08\x10\n\x0c\n\x05\x04\x08\x02\x01\x05\x12\x03J\x11\x17\n\
    \x0c\n\x05\x04\x08\x02\x01\x01\x12\x03J\x18(\n\x0c\n\x05\x04\x08\x02\x01\
    \x03\x12\x03J+,\n\n\n\x02\x04\t\x12\x04M\0W\x01\n\n\n\x03\x04\t\x01\x12\
    \x03M\x086\n\x0b\n\x04\x04\t\x02\0\x12\x03N\x083\n\x0c\n\x05\x04\t\x02\0\
    \x04\x12\x03N\x08\x10\n\x0c\n\x05\x04\t\x02\0\x05\x12\x03N\x11\x17\n\x0c\
    \n\x05\x04\t\x02\0\x01\x12\x03N\x18.\n\x0c\n\x05\x04\t\x02\0\x03\x12\x03\
    N12\n\x0b\n\x04\x04\t\x02\x01\x12\x03O\x085\n\x0c\n\x05\x04\t\x02\x01\
    \x04\x12\x03O\x08\x10\n\x0c\n\x05\x04\t\x02\x01\x05\x12\x03O\x11\x17\n\
    \x0c\n\x05\x04\t\x02\x01\x01\x12\x03O\x180\n\x0c\n\x05\x04\t\x02\x01\x03\
    \x12\x03O34\n\x0b\n\x04\x04\t\x02\x02\x12\x03P\x083\n\x0c\n\x05\x04\t\
    \x02\x02\x04\x12\x03P\x08\x10\n\x0c\n\x05\x04\t\x02\x02\x05\x12\x03P\x11\
    \x17\n\x0c\n\x05\x04\t\x02\x02\x01\x12\x03P\x18.\n\x0c\n\x05\x04\t\x02\
    \x02\x03\x12\x03P12\n\x0b\n\x04\x04\t\x02\x03\x12\x03Q\x082\n\x0c\n\x05\
    \x04\t\x02\x03\x04\x12\x03Q\x08\x10\n\x0c\n\x05\x04\t\x02\x03\x05\x12\
    \x03Q\x11\x17\n\x0c\n\x05\x04\t\x02\x03\x01\x12\x03Q\x18-\n\x0c\n\x05\
    \x04\t\x02\x03\x03\x12\x03Q01\n\x0b\n\x04\x04\t\x02\x04\x12\x03R\x08-\n\
    \x0c\n\x05\x04\t\x02\x04\x04\x12\x03R\x08\x10\n\x0c\n\x05\x04\t\x02\x04\
    \x05\x12\x03R\x11\x17\n\x0c\n\x05\x04\t\x02\x04\x01\x12\x03R\x18(\n\x0c\
    \n\x05\x04\t\x02\x04\x03\x12\x03R+,\n\x0b\n\x04\x04\t\x02\x05\x12\x03S\
    \x08/\n\x0c\n\x05\x04\t\x02\x05\x04\x12\x03S\x08\x10\n\x0c\n\x05\x04\t\
    \x02\x05\x05\x12\x03S\x11\x17\n\x0c\n\x05\x04\t\x02\x05\x01\x12\x03S\x18\
    *\n\x0c\n\x05\x04\t\x02\x05\x03\x12\x03S-.\n\x0b\n\x04\x04\t\x02\x06\x12\
    \x03T\x08-\n\x0c\n\x05\x04\t\x02\x06\x04\x12\x03T\x08\x10\n\x0c\n\x05\
    \x04\t\x02\x06\x05\x12\x03T\x11\x17\n\x0c\n\x05\x04\t\x02\x06\x01\x12\
    \x03T\x18(\n\x0c\n\x05\x04\t\x02\x06\x03\x12\x03T+,\n\x0b\n\x04\x04\t\
    \x02\x07\x12\x03U\x08,\n\x0c\n\x05\x04\t\x02\x07\x04\x12\x03U\x08\x10\n\
    \x0c\n\x05\x04\t\x02\x07\x05\x12\x03U\x11\x17\n\x0c\n\x05\x04\t\x02\x07\
    \x01\x12\x03U\x18'\n\x0c\n\x05\x04\t\x02\x07\x03\x12\x03U*+\n\x0b\n\x04\
    \x04\t\x02\x08\x12\x03V\x08,\n\x0c\n\x05\x04\t\x02\x08\x04\x12\x03V\x08\
    \x10\n\x0c\n\x05\x04\t\x02\x08\x05\x12\x03V\x11\x17\n\x0c\n\x05\x04\t\
    \x02\x08\x01\x12\x03V\x18'\n\x0c\n\x05\x04\t\x02\x08\x03\x12\x03V*+\n\n\
    \n\x02\x04\n\x12\x04Y\0[\x01\n\n\n\x03\x04\n\x01\x12\x03Y\x085\n\x0b\n\
    \x04\x04\n\x02\0\x12\x03Z\x08,\n\x0c\n\x05\x04\n\x02\0\x04\x12\x03Z\x08\
    \x10\n\x0c\n\x05\x04\n\x02\0\x05\x12\x03Z\x11\x15\n\x0c\n\x05\x04\n\x02\
    \0\x01\x12\x03Z\x16'\n\x0c\n\x05\x04\n\x02\0\x03\x12\x03Z*+\n\n\n\x02\
    \x04\x0b\x12\x04]\0a\x01\n\n\n\x03\x04\x0b\x01\x12\x03]\x086\n\x0b\n\x04\
    \x04\x0b\x02\0\x12\x03^\x08<\n\x0c\n\x05\x04\x0b\x02\0\x04\x12\x03^\x08\
    \x10\n\x0c\n\x05\x04\x0b\x02\0\x05\x12\x03^\x11\x18\n\x0c\n\x05\x04\x0b\
    \x02\0\x01\x12\x03^\x197\n\x0c\n\x05\x04\x0b\x02\0\x03\x12\x03^:;\n\x0b\
    \n\x04\x04\x0b\x02\x01\x12\x03_\x089\n\x0c\n\x05\x04\x0b\x02\x01\x04\x12\
    \x03_\x08\x10\n\x0c\n\x05\x04\x0b\x02\x01\x05\x12\x03_\x11\x18\n\x0c\n\
    \x05\x04\x0b\x02\x01\x01\x12\x03_\x194\n\x0c\n\x05\x04\x0b\x02\x01\x03\
    \x12\x03_78\n\x0b\n\x04\x04\x0b\x02\x02\x12\x03`\x08;\n\x0c\n\x05\x04\
    \x0b\x02\x02\x04\x12\x03`\x08\x10\n\x0c\n\x05\x04\x0b\x02\x02\x05\x12\
    \x03`\x11\x18\n\x0c\n\x05\x04\x0b\x02\x02\x01\x12\x03`\x196\n\x0c\n\x05\
    \x04\x0b\x02\x02\x03\x12\x03`9:\n\n\n\x02\x04\x0c\x12\x04c\0d\x01\n\n\n\
    \x03\x04\x0c\x01\x12\x03c\x081\n\n\n\x02\x04\r\x12\x04f\0i\x01\n\n\n\x03\
    \x04\r\x01\x12\x03f\x082\n\x0b\n\x04\x04\r\x02\0\x12\x03g\x08%\n\x0c\n\
    \x05\x04\r\x02\0\x04\x12\x03g\x08\x10\n\x0c\n\x05\x04\r\x02\0\x05\x12\
    \x03g\x11\x16\n\x0c\n\x05\x04\r\x02\0\x01\x12\x03g\x17\x20\n\x0c\n\x05\
    \x04\r\x02\0\x03\x12\x03g#$\n\x0b\n\x04\x04\r\x02\x01\x12\x03h\x08\"\n\
    \x0c\n\x05\x04\r\x02\x01\x04\x12\x03h\x08\x10\n\x0c\n\x05\x04\r\x02\x01\
    \x05\x12\x03h\x11\x16\n\x0c\n\x05\x04\r\x02\x01\x01\x12\x03h\x17\x1d\n\
    \x0c\n\x05\x04\r\x02\x01\x03\x12\x03h\x20!\n\x0b\n\x02\x06\0\x12\x05k\0\
    \x89\x01\x01\n\n\n\x03\x06\0\x01\x12\x03k\x08\x13\n\n\n\x03\x06\0\x03\
    \x12\x03l\x08=\n\r\n\x06\x06\0\x03\xd0\x86\x03\x12\x03l\x08=\n\x0c\n\x04\
    \x06\0\x02\0\x12\x04n\x08p\t\n\x0c\n\x05\x06\0\x02\0\x01\x12\x03n\x0c!\n\
    \x0c\n\x05\x06\0\x02\0\x02\x12\x03n#N\n\r\n\x05\x06\0\x02\0\x03\x12\x04n\
    Y\x85\x01\n\x0c\n\x05\x06\0\x02\0\x04\x12\x03o\x10G\n\x0f\n\x08\x06\0\
    \x02\0\x04\xd0\x86\x03\x12\x03o\x10G\n\x0c\n\x04\x06\0\x02\x01\x12\x04r\
    \x08t\t\n\x0c\n\x05\x06\0\x02\x01\x01\x12\x03r\x0c\x20\n\x0c\n\x05\x06\0\
    \x02\x01\x02\x12\x03r\"L\n\r\n\x05\x06\0\x02\x01\x03\x12\x04rW\x82\x01\n\
    \x0c\n\x05\x06\0\x02\x01\x04\x12\x03s\x10F\n\x0f\n\x08\x06\0\x02\x01\x04\
    \xd0\x86\x03\x12\x03s\x10F\n\x0c\n\x04\x06\0\x02\x02\x12\x04v\x08x\t\n\
    \x0c\n\x05\x06\0\x02\x02\x01\x12\x03v\x0c.\n\x0c\n\x05\x06\0\x02\x02\x02\
    \x12\x03v0b\n\r\n\x05\x06\0\x02\x02\x03\x12\x04vm\xa0\x01\n\x0c\n\x05\
    \x06\0\x02\x02\x04\x12\x03w\x10T\n\x0f\n\x08\x06\0\x02\x02\x04\xd0\x86\
    \x03\x12\x03w\x10T\n\x0c\n\x04\x06\0\x02\x03\x12\x04z\x08|\t\n\x0c\n\x05\
    \x06\0\x02\x03\x01\x12\x03z\x0c\x20\n\x0c\n\x05\x06\0\x02\x03\x02\x12\
    \x03z\"L\n\r\n\x05\x06\0\x02\x03\x03\x12\x04zW\x82\x01\n\x0c\n\x05\x06\0\
    \x02\x03\x04\x12\x03{\x10X\n\x0f\n\x08\x06\0\x02\x03\x04\xd0\x86\x03\x12\
    \x03{\x10X\n\r\n\x04\x06\0\x02\x04\x12\x05~\x08\x80\x01\t\n\x0c\n\x05\
    \x06\0\x02\x04\x01\x12\x03~\x0c$\n\x0c\n\x05\x06\0\x02\x04\x02\x12\x03~&\
    T\n\r\n\x05\x06\0\x02\x04\x03\x12\x04~_\x8e\x01\n\x0c\n\x05\x06\0\x02\
    \x04\x04\x12\x03\x7f\x10I\n\x0f\n\x08\x06\0\x02\x04\x04\xd0\x86\x03\x12\
    \x03\x7f\x10I\n\x0e\n\x04\x06\0\x02\x05\x12\x06\x82\x01\x08\x84\x01\t\n\
    \r\n\x05\x06\0\x02\x05\x01\x12\x04\x82\x01\x0c*\n\r\n\x05\x06\0\x02\x05\
    \x02\x12\x04\x82\x01,Z\n\x0e\n\x05\x06\0\x02\x05\x03\x12\x05\x82\x01e\
    \x94\x01\n\r\n\x05\x06\0\x02\x05\x04\x12\x04\x83\x01\x10P\n\x10\n\x08\
    \x06\0\x02\x05\x04\xd0\x86\x03\x12\x04\x83\x01\x10P\n\x0e\n\x04\x06\0\
    \x02\x06\x12\x06\x86\x01\x08\x88\x01\t\n\r\n\x05\x06\0\x02\x06\x01\x12\
    \x04\x86\x01\x0c\x20\n\r\n\x05\x06\0\x02\x06\x02\x12\x04\x86\x01\"L\n\
    \x0e\n\x05\x06\0\x02\x06\x03\x12\x05\x86\x01W\x82\x01\n\r\n\x05\x06\0\
    \x02\x06\x04\x12\x04\x87\x01\x10E\n\x10\n\x08\x06\0\x02\x06\x04\xd0\x86\
    \x03\x12\x04\x87\x01\x10E\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}