steam-protobuf 0.1.2

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

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

#![allow(unused_attributes)]
#![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_20_0;

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
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
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CCredentials_TestAvailablePassword_Response {
    // message fields
    is_valid: ::std::option::Option<bool>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
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
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
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
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
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
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
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
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CCredentials_NewMachineNotificationDialog_Request {
    // message fields
    is_approved: ::std::option::Option<bool>,
    is_wizard_complete: ::std::option::Option<bool>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CCredentials_NewMachineNotificationDialog_Response {
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CCredentials_ValidateEmailAddress_Request {
    // message fields
    stoken: ::protobuf::SingularField<::std::string::String>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CCredentials_ValidateEmailAddress_Response {
    // message fields
    was_validated: ::std::option::Option<bool>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CCredentials_SteamGuardPhishingReport_Request {
    // message fields
    param_string: ::protobuf::SingularField<::std::string::String>,
    ipaddress_actual: ::protobuf::SingularField<::std::string::String>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
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
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CCredentials_LastCredentialChangeTime_Request {
    // message fields
    user_changes_only: ::std::option::Option<bool>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
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
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CCredentials_GetAccountAuthSecret_Request {
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CCredentials_GetAccountAuthSecret_Response {
    // message fields
    secret_id: ::std::option::Option<i32>,
    secret: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    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\x01\
";

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