#![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)]
#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CTwoFactor_Status_Request {
steamid: ::std::option::Option<u64>,
#[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 CTwoFactor_Status_Request {
fn default() -> &'a CTwoFactor_Status_Request {
<CTwoFactor_Status_Request as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_Status_Request {
pub fn new() -> CTwoFactor_Status_Request {
::std::default::Default::default()
}
pub fn get_steamid(&self) -> u64 {
self.steamid.unwrap_or(0)
}
pub fn clear_steamid(&mut self) {
self.steamid = ::std::option::Option::None;
}
pub fn has_steamid(&self) -> bool {
self.steamid.is_some()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CTwoFactor_Status_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::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.steamid = ::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(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.steamid {
my_size += 9;
}
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.steamid {
os.write_fixed64(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() -> CTwoFactor_Status_Request {
CTwoFactor_Status_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::ProtobufTypeFixed64>(
"steamid",
|m: &CTwoFactor_Status_Request| { &m.steamid },
|m: &mut CTwoFactor_Status_Request| { &mut m.steamid },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_Status_Request>(
"CTwoFactor_Status_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_Status_Request {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_Status_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_Status_Request::new)
}
}
impl ::protobuf::Clear for CTwoFactor_Status_Request {
fn clear(&mut self) {
self.steamid = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_Status_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_Status_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 CTwoFactor_Status_Response {
state: ::std::option::Option<u32>,
inactivation_reason: ::std::option::Option<u32>,
authenticator_type: ::std::option::Option<u32>,
authenticator_allowed: ::std::option::Option<bool>,
steamguard_scheme: ::std::option::Option<u32>,
token_gid: ::protobuf::SingularField<::std::string::String>,
email_validated: ::std::option::Option<bool>,
device_identifier: ::protobuf::SingularField<::std::string::String>,
time_created: ::std::option::Option<u32>,
revocation_attempts_remaining: ::std::option::Option<u32>,
classified_agent: ::protobuf::SingularField<::std::string::String>,
allow_external_authenticator: ::std::option::Option<bool>,
time_transferred: ::std::option::Option<u32>,
#[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 CTwoFactor_Status_Response {
fn default() -> &'a CTwoFactor_Status_Response {
<CTwoFactor_Status_Response as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_Status_Response {
pub fn new() -> CTwoFactor_Status_Response {
::std::default::Default::default()
}
pub fn get_state(&self) -> u32 {
self.state.unwrap_or(0)
}
pub fn clear_state(&mut self) {
self.state = ::std::option::Option::None;
}
pub fn has_state(&self) -> bool {
self.state.is_some()
}
pub fn set_state(&mut self, v: u32) {
self.state = ::std::option::Option::Some(v);
}
pub fn get_inactivation_reason(&self) -> u32 {
self.inactivation_reason.unwrap_or(0)
}
pub fn clear_inactivation_reason(&mut self) {
self.inactivation_reason = ::std::option::Option::None;
}
pub fn has_inactivation_reason(&self) -> bool {
self.inactivation_reason.is_some()
}
pub fn set_inactivation_reason(&mut self, v: u32) {
self.inactivation_reason = ::std::option::Option::Some(v);
}
pub fn get_authenticator_type(&self) -> u32 {
self.authenticator_type.unwrap_or(0)
}
pub fn clear_authenticator_type(&mut self) {
self.authenticator_type = ::std::option::Option::None;
}
pub fn has_authenticator_type(&self) -> bool {
self.authenticator_type.is_some()
}
pub fn set_authenticator_type(&mut self, v: u32) {
self.authenticator_type = ::std::option::Option::Some(v);
}
pub fn get_authenticator_allowed(&self) -> bool {
self.authenticator_allowed.unwrap_or(false)
}
pub fn clear_authenticator_allowed(&mut self) {
self.authenticator_allowed = ::std::option::Option::None;
}
pub fn has_authenticator_allowed(&self) -> bool {
self.authenticator_allowed.is_some()
}
pub fn set_authenticator_allowed(&mut self, v: bool) {
self.authenticator_allowed = ::std::option::Option::Some(v);
}
pub fn get_steamguard_scheme(&self) -> u32 {
self.steamguard_scheme.unwrap_or(0)
}
pub fn clear_steamguard_scheme(&mut self) {
self.steamguard_scheme = ::std::option::Option::None;
}
pub fn has_steamguard_scheme(&self) -> bool {
self.steamguard_scheme.is_some()
}
pub fn set_steamguard_scheme(&mut self, v: u32) {
self.steamguard_scheme = ::std::option::Option::Some(v);
}
pub fn get_token_gid(&self) -> &str {
match self.token_gid.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_token_gid(&mut self) {
self.token_gid.clear();
}
pub fn has_token_gid(&self) -> bool {
self.token_gid.is_some()
}
pub fn set_token_gid(&mut self, v: ::std::string::String) {
self.token_gid = ::protobuf::SingularField::some(v);
}
pub fn mut_token_gid(&mut self) -> &mut ::std::string::String {
if self.token_gid.is_none() {
self.token_gid.set_default();
}
self.token_gid.as_mut().unwrap()
}
pub fn take_token_gid(&mut self) -> ::std::string::String {
self.token_gid.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_email_validated(&self) -> bool {
self.email_validated.unwrap_or(false)
}
pub fn clear_email_validated(&mut self) {
self.email_validated = ::std::option::Option::None;
}
pub fn has_email_validated(&self) -> bool {
self.email_validated.is_some()
}
pub fn set_email_validated(&mut self, v: bool) {
self.email_validated = ::std::option::Option::Some(v);
}
pub fn get_device_identifier(&self) -> &str {
match self.device_identifier.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_device_identifier(&mut self) {
self.device_identifier.clear();
}
pub fn has_device_identifier(&self) -> bool {
self.device_identifier.is_some()
}
pub fn set_device_identifier(&mut self, v: ::std::string::String) {
self.device_identifier = ::protobuf::SingularField::some(v);
}
pub fn mut_device_identifier(&mut self) -> &mut ::std::string::String {
if self.device_identifier.is_none() {
self.device_identifier.set_default();
}
self.device_identifier.as_mut().unwrap()
}
pub fn take_device_identifier(&mut self) -> ::std::string::String {
self.device_identifier.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_time_created(&self) -> u32 {
self.time_created.unwrap_or(0)
}
pub fn clear_time_created(&mut self) {
self.time_created = ::std::option::Option::None;
}
pub fn has_time_created(&self) -> bool {
self.time_created.is_some()
}
pub fn set_time_created(&mut self, v: u32) {
self.time_created = ::std::option::Option::Some(v);
}
pub fn get_revocation_attempts_remaining(&self) -> u32 {
self.revocation_attempts_remaining.unwrap_or(0)
}
pub fn clear_revocation_attempts_remaining(&mut self) {
self.revocation_attempts_remaining = ::std::option::Option::None;
}
pub fn has_revocation_attempts_remaining(&self) -> bool {
self.revocation_attempts_remaining.is_some()
}
pub fn set_revocation_attempts_remaining(&mut self, v: u32) {
self.revocation_attempts_remaining = ::std::option::Option::Some(v);
}
pub fn get_classified_agent(&self) -> &str {
match self.classified_agent.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_classified_agent(&mut self) {
self.classified_agent.clear();
}
pub fn has_classified_agent(&self) -> bool {
self.classified_agent.is_some()
}
pub fn set_classified_agent(&mut self, v: ::std::string::String) {
self.classified_agent = ::protobuf::SingularField::some(v);
}
pub fn mut_classified_agent(&mut self) -> &mut ::std::string::String {
if self.classified_agent.is_none() {
self.classified_agent.set_default();
}
self.classified_agent.as_mut().unwrap()
}
pub fn take_classified_agent(&mut self) -> ::std::string::String {
self.classified_agent.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_allow_external_authenticator(&self) -> bool {
self.allow_external_authenticator.unwrap_or(false)
}
pub fn clear_allow_external_authenticator(&mut self) {
self.allow_external_authenticator = ::std::option::Option::None;
}
pub fn has_allow_external_authenticator(&self) -> bool {
self.allow_external_authenticator.is_some()
}
pub fn set_allow_external_authenticator(&mut self, v: bool) {
self.allow_external_authenticator = ::std::option::Option::Some(v);
}
pub fn get_time_transferred(&self) -> u32 {
self.time_transferred.unwrap_or(0)
}
pub fn clear_time_transferred(&mut self) {
self.time_transferred = ::std::option::Option::None;
}
pub fn has_time_transferred(&self) -> bool {
self.time_transferred.is_some()
}
pub fn set_time_transferred(&mut self, v: u32) {
self.time_transferred = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CTwoFactor_Status_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_uint32()?;
self.state = ::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_uint32()?;
self.inactivation_reason = ::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_uint32()?;
self.authenticator_type = ::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.authenticator_allowed = ::std::option::Option::Some(tmp);
},
5 => {
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.steamguard_scheme = ::std::option::Option::Some(tmp);
},
6 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.token_gid)?;
},
7 => {
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.email_validated = ::std::option::Option::Some(tmp);
},
8 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.device_identifier)?;
},
9 => {
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.time_created = ::std::option::Option::Some(tmp);
},
10 => {
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.revocation_attempts_remaining = ::std::option::Option::Some(tmp);
},
11 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.classified_agent)?;
},
12 => {
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.allow_external_authenticator = ::std::option::Option::Some(tmp);
},
13 => {
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.time_transferred = ::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(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.state {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.inactivation_reason {
my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.authenticator_type {
my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.authenticator_allowed {
my_size += 2;
}
if let Some(v) = self.steamguard_scheme {
my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.token_gid.as_ref() {
my_size += ::protobuf::rt::string_size(6, &v);
}
if let Some(v) = self.email_validated {
my_size += 2;
}
if let Some(ref v) = self.device_identifier.as_ref() {
my_size += ::protobuf::rt::string_size(8, &v);
}
if let Some(v) = self.time_created {
my_size += ::protobuf::rt::value_size(9, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.revocation_attempts_remaining {
my_size += ::protobuf::rt::value_size(10, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.classified_agent.as_ref() {
my_size += ::protobuf::rt::string_size(11, &v);
}
if let Some(v) = self.allow_external_authenticator {
my_size += 2;
}
if let Some(v) = self.time_transferred {
my_size += ::protobuf::rt::value_size(13, 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.state {
os.write_uint32(1, v)?;
}
if let Some(v) = self.inactivation_reason {
os.write_uint32(2, v)?;
}
if let Some(v) = self.authenticator_type {
os.write_uint32(3, v)?;
}
if let Some(v) = self.authenticator_allowed {
os.write_bool(4, v)?;
}
if let Some(v) = self.steamguard_scheme {
os.write_uint32(5, v)?;
}
if let Some(ref v) = self.token_gid.as_ref() {
os.write_string(6, &v)?;
}
if let Some(v) = self.email_validated {
os.write_bool(7, v)?;
}
if let Some(ref v) = self.device_identifier.as_ref() {
os.write_string(8, &v)?;
}
if let Some(v) = self.time_created {
os.write_uint32(9, v)?;
}
if let Some(v) = self.revocation_attempts_remaining {
os.write_uint32(10, v)?;
}
if let Some(ref v) = self.classified_agent.as_ref() {
os.write_string(11, &v)?;
}
if let Some(v) = self.allow_external_authenticator {
os.write_bool(12, v)?;
}
if let Some(v) = self.time_transferred {
os.write_uint32(13, 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() -> CTwoFactor_Status_Response {
CTwoFactor_Status_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::ProtobufTypeUint32>(
"state",
|m: &CTwoFactor_Status_Response| { &m.state },
|m: &mut CTwoFactor_Status_Response| { &mut m.state },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"inactivation_reason",
|m: &CTwoFactor_Status_Response| { &m.inactivation_reason },
|m: &mut CTwoFactor_Status_Response| { &mut m.inactivation_reason },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"authenticator_type",
|m: &CTwoFactor_Status_Response| { &m.authenticator_type },
|m: &mut CTwoFactor_Status_Response| { &mut m.authenticator_type },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"authenticator_allowed",
|m: &CTwoFactor_Status_Response| { &m.authenticator_allowed },
|m: &mut CTwoFactor_Status_Response| { &mut m.authenticator_allowed },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"steamguard_scheme",
|m: &CTwoFactor_Status_Response| { &m.steamguard_scheme },
|m: &mut CTwoFactor_Status_Response| { &mut m.steamguard_scheme },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"token_gid",
|m: &CTwoFactor_Status_Response| { &m.token_gid },
|m: &mut CTwoFactor_Status_Response| { &mut m.token_gid },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"email_validated",
|m: &CTwoFactor_Status_Response| { &m.email_validated },
|m: &mut CTwoFactor_Status_Response| { &mut m.email_validated },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"device_identifier",
|m: &CTwoFactor_Status_Response| { &m.device_identifier },
|m: &mut CTwoFactor_Status_Response| { &mut m.device_identifier },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"time_created",
|m: &CTwoFactor_Status_Response| { &m.time_created },
|m: &mut CTwoFactor_Status_Response| { &mut m.time_created },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"revocation_attempts_remaining",
|m: &CTwoFactor_Status_Response| { &m.revocation_attempts_remaining },
|m: &mut CTwoFactor_Status_Response| { &mut m.revocation_attempts_remaining },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"classified_agent",
|m: &CTwoFactor_Status_Response| { &m.classified_agent },
|m: &mut CTwoFactor_Status_Response| { &mut m.classified_agent },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"allow_external_authenticator",
|m: &CTwoFactor_Status_Response| { &m.allow_external_authenticator },
|m: &mut CTwoFactor_Status_Response| { &mut m.allow_external_authenticator },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"time_transferred",
|m: &CTwoFactor_Status_Response| { &m.time_transferred },
|m: &mut CTwoFactor_Status_Response| { &mut m.time_transferred },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_Status_Response>(
"CTwoFactor_Status_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_Status_Response {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_Status_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_Status_Response::new)
}
}
impl ::protobuf::Clear for CTwoFactor_Status_Response {
fn clear(&mut self) {
self.state = ::std::option::Option::None;
self.inactivation_reason = ::std::option::Option::None;
self.authenticator_type = ::std::option::Option::None;
self.authenticator_allowed = ::std::option::Option::None;
self.steamguard_scheme = ::std::option::Option::None;
self.token_gid.clear();
self.email_validated = ::std::option::Option::None;
self.device_identifier.clear();
self.time_created = ::std::option::Option::None;
self.revocation_attempts_remaining = ::std::option::Option::None;
self.classified_agent.clear();
self.allow_external_authenticator = ::std::option::Option::None;
self.time_transferred = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_Status_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_Status_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 CTwoFactor_AddAuthenticator_Request {
steamid: ::std::option::Option<u64>,
authenticator_time: ::std::option::Option<u64>,
serial_number: ::std::option::Option<u64>,
authenticator_type: ::std::option::Option<u32>,
device_identifier: ::protobuf::SingularField<::std::string::String>,
sms_phone_id: ::protobuf::SingularField<::std::string::String>,
pub http_headers: ::protobuf::RepeatedField<::std::string::String>,
#[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 CTwoFactor_AddAuthenticator_Request {
fn default() -> &'a CTwoFactor_AddAuthenticator_Request {
<CTwoFactor_AddAuthenticator_Request as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_AddAuthenticator_Request {
pub fn new() -> CTwoFactor_AddAuthenticator_Request {
::std::default::Default::default()
}
pub fn get_steamid(&self) -> u64 {
self.steamid.unwrap_or(0)
}
pub fn clear_steamid(&mut self) {
self.steamid = ::std::option::Option::None;
}
pub fn has_steamid(&self) -> bool {
self.steamid.is_some()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
pub fn get_authenticator_time(&self) -> u64 {
self.authenticator_time.unwrap_or(0)
}
pub fn clear_authenticator_time(&mut self) {
self.authenticator_time = ::std::option::Option::None;
}
pub fn has_authenticator_time(&self) -> bool {
self.authenticator_time.is_some()
}
pub fn set_authenticator_time(&mut self, v: u64) {
self.authenticator_time = ::std::option::Option::Some(v);
}
pub fn get_serial_number(&self) -> u64 {
self.serial_number.unwrap_or(0)
}
pub fn clear_serial_number(&mut self) {
self.serial_number = ::std::option::Option::None;
}
pub fn has_serial_number(&self) -> bool {
self.serial_number.is_some()
}
pub fn set_serial_number(&mut self, v: u64) {
self.serial_number = ::std::option::Option::Some(v);
}
pub fn get_authenticator_type(&self) -> u32 {
self.authenticator_type.unwrap_or(0)
}
pub fn clear_authenticator_type(&mut self) {
self.authenticator_type = ::std::option::Option::None;
}
pub fn has_authenticator_type(&self) -> bool {
self.authenticator_type.is_some()
}
pub fn set_authenticator_type(&mut self, v: u32) {
self.authenticator_type = ::std::option::Option::Some(v);
}
pub fn get_device_identifier(&self) -> &str {
match self.device_identifier.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_device_identifier(&mut self) {
self.device_identifier.clear();
}
pub fn has_device_identifier(&self) -> bool {
self.device_identifier.is_some()
}
pub fn set_device_identifier(&mut self, v: ::std::string::String) {
self.device_identifier = ::protobuf::SingularField::some(v);
}
pub fn mut_device_identifier(&mut self) -> &mut ::std::string::String {
if self.device_identifier.is_none() {
self.device_identifier.set_default();
}
self.device_identifier.as_mut().unwrap()
}
pub fn take_device_identifier(&mut self) -> ::std::string::String {
self.device_identifier.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_sms_phone_id(&self) -> &str {
match self.sms_phone_id.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_sms_phone_id(&mut self) {
self.sms_phone_id.clear();
}
pub fn has_sms_phone_id(&self) -> bool {
self.sms_phone_id.is_some()
}
pub fn set_sms_phone_id(&mut self, v: ::std::string::String) {
self.sms_phone_id = ::protobuf::SingularField::some(v);
}
pub fn mut_sms_phone_id(&mut self) -> &mut ::std::string::String {
if self.sms_phone_id.is_none() {
self.sms_phone_id.set_default();
}
self.sms_phone_id.as_mut().unwrap()
}
pub fn take_sms_phone_id(&mut self) -> ::std::string::String {
self.sms_phone_id.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_http_headers(&self) -> &[::std::string::String] {
&self.http_headers
}
pub fn clear_http_headers(&mut self) {
self.http_headers.clear();
}
pub fn set_http_headers(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.http_headers = v;
}
pub fn mut_http_headers(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.http_headers
}
pub fn take_http_headers(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.http_headers, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for CTwoFactor_AddAuthenticator_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::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.steamid = ::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_uint64()?;
self.authenticator_time = ::std::option::Option::Some(tmp);
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.serial_number = ::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_uint32()?;
self.authenticator_type = ::std::option::Option::Some(tmp);
},
5 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.device_identifier)?;
},
6 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.sms_phone_id)?;
},
7 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.http_headers)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.steamid {
my_size += 9;
}
if let Some(v) = self.authenticator_time {
my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.serial_number {
my_size += 9;
}
if let Some(v) = self.authenticator_type {
my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.device_identifier.as_ref() {
my_size += ::protobuf::rt::string_size(5, &v);
}
if let Some(ref v) = self.sms_phone_id.as_ref() {
my_size += ::protobuf::rt::string_size(6, &v);
}
for value in &self.http_headers {
my_size += ::protobuf::rt::string_size(7, &value);
};
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.steamid {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.authenticator_time {
os.write_uint64(2, v)?;
}
if let Some(v) = self.serial_number {
os.write_fixed64(3, v)?;
}
if let Some(v) = self.authenticator_type {
os.write_uint32(4, v)?;
}
if let Some(ref v) = self.device_identifier.as_ref() {
os.write_string(5, &v)?;
}
if let Some(ref v) = self.sms_phone_id.as_ref() {
os.write_string(6, &v)?;
}
for v in &self.http_headers {
os.write_string(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() -> CTwoFactor_AddAuthenticator_Request {
CTwoFactor_AddAuthenticator_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::ProtobufTypeFixed64>(
"steamid",
|m: &CTwoFactor_AddAuthenticator_Request| { &m.steamid },
|m: &mut CTwoFactor_AddAuthenticator_Request| { &mut m.steamid },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"authenticator_time",
|m: &CTwoFactor_AddAuthenticator_Request| { &m.authenticator_time },
|m: &mut CTwoFactor_AddAuthenticator_Request| { &mut m.authenticator_time },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"serial_number",
|m: &CTwoFactor_AddAuthenticator_Request| { &m.serial_number },
|m: &mut CTwoFactor_AddAuthenticator_Request| { &mut m.serial_number },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"authenticator_type",
|m: &CTwoFactor_AddAuthenticator_Request| { &m.authenticator_type },
|m: &mut CTwoFactor_AddAuthenticator_Request| { &mut m.authenticator_type },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"device_identifier",
|m: &CTwoFactor_AddAuthenticator_Request| { &m.device_identifier },
|m: &mut CTwoFactor_AddAuthenticator_Request| { &mut m.device_identifier },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"sms_phone_id",
|m: &CTwoFactor_AddAuthenticator_Request| { &m.sms_phone_id },
|m: &mut CTwoFactor_AddAuthenticator_Request| { &mut m.sms_phone_id },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"http_headers",
|m: &CTwoFactor_AddAuthenticator_Request| { &m.http_headers },
|m: &mut CTwoFactor_AddAuthenticator_Request| { &mut m.http_headers },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_AddAuthenticator_Request>(
"CTwoFactor_AddAuthenticator_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_AddAuthenticator_Request {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_AddAuthenticator_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_AddAuthenticator_Request::new)
}
}
impl ::protobuf::Clear for CTwoFactor_AddAuthenticator_Request {
fn clear(&mut self) {
self.steamid = ::std::option::Option::None;
self.authenticator_time = ::std::option::Option::None;
self.serial_number = ::std::option::Option::None;
self.authenticator_type = ::std::option::Option::None;
self.device_identifier.clear();
self.sms_phone_id.clear();
self.http_headers.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_AddAuthenticator_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_AddAuthenticator_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 CTwoFactor_AddAuthenticator_Response {
shared_secret: ::protobuf::SingularField<::std::vec::Vec<u8>>,
serial_number: ::std::option::Option<u64>,
revocation_code: ::protobuf::SingularField<::std::string::String>,
uri: ::protobuf::SingularField<::std::string::String>,
server_time: ::std::option::Option<u64>,
account_name: ::protobuf::SingularField<::std::string::String>,
token_gid: ::protobuf::SingularField<::std::string::String>,
identity_secret: ::protobuf::SingularField<::std::vec::Vec<u8>>,
secret_1: ::protobuf::SingularField<::std::vec::Vec<u8>>,
status: ::std::option::Option<i32>,
#[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 CTwoFactor_AddAuthenticator_Response {
fn default() -> &'a CTwoFactor_AddAuthenticator_Response {
<CTwoFactor_AddAuthenticator_Response as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_AddAuthenticator_Response {
pub fn new() -> CTwoFactor_AddAuthenticator_Response {
::std::default::Default::default()
}
pub fn get_shared_secret(&self) -> &[u8] {
match self.shared_secret.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_shared_secret(&mut self) {
self.shared_secret.clear();
}
pub fn has_shared_secret(&self) -> bool {
self.shared_secret.is_some()
}
pub fn set_shared_secret(&mut self, v: ::std::vec::Vec<u8>) {
self.shared_secret = ::protobuf::SingularField::some(v);
}
pub fn mut_shared_secret(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.shared_secret.is_none() {
self.shared_secret.set_default();
}
self.shared_secret.as_mut().unwrap()
}
pub fn take_shared_secret(&mut self) -> ::std::vec::Vec<u8> {
self.shared_secret.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_serial_number(&self) -> u64 {
self.serial_number.unwrap_or(0)
}
pub fn clear_serial_number(&mut self) {
self.serial_number = ::std::option::Option::None;
}
pub fn has_serial_number(&self) -> bool {
self.serial_number.is_some()
}
pub fn set_serial_number(&mut self, v: u64) {
self.serial_number = ::std::option::Option::Some(v);
}
pub fn get_revocation_code(&self) -> &str {
match self.revocation_code.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_revocation_code(&mut self) {
self.revocation_code.clear();
}
pub fn has_revocation_code(&self) -> bool {
self.revocation_code.is_some()
}
pub fn set_revocation_code(&mut self, v: ::std::string::String) {
self.revocation_code = ::protobuf::SingularField::some(v);
}
pub fn mut_revocation_code(&mut self) -> &mut ::std::string::String {
if self.revocation_code.is_none() {
self.revocation_code.set_default();
}
self.revocation_code.as_mut().unwrap()
}
pub fn take_revocation_code(&mut self) -> ::std::string::String {
self.revocation_code.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_uri(&self) -> &str {
match self.uri.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_uri(&mut self) {
self.uri.clear();
}
pub fn has_uri(&self) -> bool {
self.uri.is_some()
}
pub fn set_uri(&mut self, v: ::std::string::String) {
self.uri = ::protobuf::SingularField::some(v);
}
pub fn mut_uri(&mut self) -> &mut ::std::string::String {
if self.uri.is_none() {
self.uri.set_default();
}
self.uri.as_mut().unwrap()
}
pub fn take_uri(&mut self) -> ::std::string::String {
self.uri.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_server_time(&self) -> u64 {
self.server_time.unwrap_or(0)
}
pub fn clear_server_time(&mut self) {
self.server_time = ::std::option::Option::None;
}
pub fn has_server_time(&self) -> bool {
self.server_time.is_some()
}
pub fn set_server_time(&mut self, v: u64) {
self.server_time = ::std::option::Option::Some(v);
}
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()
}
pub fn set_account_name(&mut self, v: ::std::string::String) {
self.account_name = ::protobuf::SingularField::some(v);
}
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()
}
pub fn take_account_name(&mut self) -> ::std::string::String {
self.account_name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_token_gid(&self) -> &str {
match self.token_gid.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_token_gid(&mut self) {
self.token_gid.clear();
}
pub fn has_token_gid(&self) -> bool {
self.token_gid.is_some()
}
pub fn set_token_gid(&mut self, v: ::std::string::String) {
self.token_gid = ::protobuf::SingularField::some(v);
}
pub fn mut_token_gid(&mut self) -> &mut ::std::string::String {
if self.token_gid.is_none() {
self.token_gid.set_default();
}
self.token_gid.as_mut().unwrap()
}
pub fn take_token_gid(&mut self) -> ::std::string::String {
self.token_gid.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_identity_secret(&self) -> &[u8] {
match self.identity_secret.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_identity_secret(&mut self) {
self.identity_secret.clear();
}
pub fn has_identity_secret(&self) -> bool {
self.identity_secret.is_some()
}
pub fn set_identity_secret(&mut self, v: ::std::vec::Vec<u8>) {
self.identity_secret = ::protobuf::SingularField::some(v);
}
pub fn mut_identity_secret(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.identity_secret.is_none() {
self.identity_secret.set_default();
}
self.identity_secret.as_mut().unwrap()
}
pub fn take_identity_secret(&mut self) -> ::std::vec::Vec<u8> {
self.identity_secret.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_secret_1(&self) -> &[u8] {
match self.secret_1.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_secret_1(&mut self) {
self.secret_1.clear();
}
pub fn has_secret_1(&self) -> bool {
self.secret_1.is_some()
}
pub fn set_secret_1(&mut self, v: ::std::vec::Vec<u8>) {
self.secret_1 = ::protobuf::SingularField::some(v);
}
pub fn mut_secret_1(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.secret_1.is_none() {
self.secret_1.set_default();
}
self.secret_1.as_mut().unwrap()
}
pub fn take_secret_1(&mut self) -> ::std::vec::Vec<u8> {
self.secret_1.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
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()
}
pub fn set_status(&mut self, v: i32) {
self.status = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CTwoFactor_AddAuthenticator_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_bytes_into(wire_type, is, &mut self.shared_secret)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.serial_number = ::std::option::Option::Some(tmp);
},
3 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.revocation_code)?;
},
4 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.uri)?;
},
5 => {
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.server_time = ::std::option::Option::Some(tmp);
},
6 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.account_name)?;
},
7 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.token_gid)?;
},
8 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.identity_secret)?;
},
9 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.secret_1)?;
},
10 => {
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(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.shared_secret.as_ref() {
my_size += ::protobuf::rt::bytes_size(1, &v);
}
if let Some(v) = self.serial_number {
my_size += 9;
}
if let Some(ref v) = self.revocation_code.as_ref() {
my_size += ::protobuf::rt::string_size(3, &v);
}
if let Some(ref v) = self.uri.as_ref() {
my_size += ::protobuf::rt::string_size(4, &v);
}
if let Some(v) = self.server_time {
my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.account_name.as_ref() {
my_size += ::protobuf::rt::string_size(6, &v);
}
if let Some(ref v) = self.token_gid.as_ref() {
my_size += ::protobuf::rt::string_size(7, &v);
}
if let Some(ref v) = self.identity_secret.as_ref() {
my_size += ::protobuf::rt::bytes_size(8, &v);
}
if let Some(ref v) = self.secret_1.as_ref() {
my_size += ::protobuf::rt::bytes_size(9, &v);
}
if let Some(v) = self.status {
my_size += ::protobuf::rt::value_size(10, 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(ref v) = self.shared_secret.as_ref() {
os.write_bytes(1, &v)?;
}
if let Some(v) = self.serial_number {
os.write_fixed64(2, v)?;
}
if let Some(ref v) = self.revocation_code.as_ref() {
os.write_string(3, &v)?;
}
if let Some(ref v) = self.uri.as_ref() {
os.write_string(4, &v)?;
}
if let Some(v) = self.server_time {
os.write_uint64(5, v)?;
}
if let Some(ref v) = self.account_name.as_ref() {
os.write_string(6, &v)?;
}
if let Some(ref v) = self.token_gid.as_ref() {
os.write_string(7, &v)?;
}
if let Some(ref v) = self.identity_secret.as_ref() {
os.write_bytes(8, &v)?;
}
if let Some(ref v) = self.secret_1.as_ref() {
os.write_bytes(9, &v)?;
}
if let Some(v) = self.status {
os.write_int32(10, 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() -> CTwoFactor_AddAuthenticator_Response {
CTwoFactor_AddAuthenticator_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::ProtobufTypeBytes>(
"shared_secret",
|m: &CTwoFactor_AddAuthenticator_Response| { &m.shared_secret },
|m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.shared_secret },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"serial_number",
|m: &CTwoFactor_AddAuthenticator_Response| { &m.serial_number },
|m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.serial_number },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"revocation_code",
|m: &CTwoFactor_AddAuthenticator_Response| { &m.revocation_code },
|m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.revocation_code },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"uri",
|m: &CTwoFactor_AddAuthenticator_Response| { &m.uri },
|m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.uri },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"server_time",
|m: &CTwoFactor_AddAuthenticator_Response| { &m.server_time },
|m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.server_time },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"account_name",
|m: &CTwoFactor_AddAuthenticator_Response| { &m.account_name },
|m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.account_name },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"token_gid",
|m: &CTwoFactor_AddAuthenticator_Response| { &m.token_gid },
|m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.token_gid },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"identity_secret",
|m: &CTwoFactor_AddAuthenticator_Response| { &m.identity_secret },
|m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.identity_secret },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"secret_1",
|m: &CTwoFactor_AddAuthenticator_Response| { &m.secret_1 },
|m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.secret_1 },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"status",
|m: &CTwoFactor_AddAuthenticator_Response| { &m.status },
|m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.status },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_AddAuthenticator_Response>(
"CTwoFactor_AddAuthenticator_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_AddAuthenticator_Response {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_AddAuthenticator_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_AddAuthenticator_Response::new)
}
}
impl ::protobuf::Clear for CTwoFactor_AddAuthenticator_Response {
fn clear(&mut self) {
self.shared_secret.clear();
self.serial_number = ::std::option::Option::None;
self.revocation_code.clear();
self.uri.clear();
self.server_time = ::std::option::Option::None;
self.account_name.clear();
self.token_gid.clear();
self.identity_secret.clear();
self.secret_1.clear();
self.status = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_AddAuthenticator_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_AddAuthenticator_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 CTwoFactor_SendEmail_Request {
steamid: ::std::option::Option<u64>,
email_type: ::std::option::Option<u32>,
include_activation_code: ::std::option::Option<bool>,
#[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 CTwoFactor_SendEmail_Request {
fn default() -> &'a CTwoFactor_SendEmail_Request {
<CTwoFactor_SendEmail_Request as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_SendEmail_Request {
pub fn new() -> CTwoFactor_SendEmail_Request {
::std::default::Default::default()
}
pub fn get_steamid(&self) -> u64 {
self.steamid.unwrap_or(0)
}
pub fn clear_steamid(&mut self) {
self.steamid = ::std::option::Option::None;
}
pub fn has_steamid(&self) -> bool {
self.steamid.is_some()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
pub fn get_email_type(&self) -> u32 {
self.email_type.unwrap_or(0)
}
pub fn clear_email_type(&mut self) {
self.email_type = ::std::option::Option::None;
}
pub fn has_email_type(&self) -> bool {
self.email_type.is_some()
}
pub fn set_email_type(&mut self, v: u32) {
self.email_type = ::std::option::Option::Some(v);
}
pub fn get_include_activation_code(&self) -> bool {
self.include_activation_code.unwrap_or(false)
}
pub fn clear_include_activation_code(&mut self) {
self.include_activation_code = ::std::option::Option::None;
}
pub fn has_include_activation_code(&self) -> bool {
self.include_activation_code.is_some()
}
pub fn set_include_activation_code(&mut self, v: bool) {
self.include_activation_code = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CTwoFactor_SendEmail_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::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.steamid = ::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_uint32()?;
self.email_type = ::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_bool()?;
self.include_activation_code = ::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(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.steamid {
my_size += 9;
}
if let Some(v) = self.email_type {
my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.include_activation_code {
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.steamid {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.email_type {
os.write_uint32(2, v)?;
}
if let Some(v) = self.include_activation_code {
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() -> CTwoFactor_SendEmail_Request {
CTwoFactor_SendEmail_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::ProtobufTypeFixed64>(
"steamid",
|m: &CTwoFactor_SendEmail_Request| { &m.steamid },
|m: &mut CTwoFactor_SendEmail_Request| { &mut m.steamid },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"email_type",
|m: &CTwoFactor_SendEmail_Request| { &m.email_type },
|m: &mut CTwoFactor_SendEmail_Request| { &mut m.email_type },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"include_activation_code",
|m: &CTwoFactor_SendEmail_Request| { &m.include_activation_code },
|m: &mut CTwoFactor_SendEmail_Request| { &mut m.include_activation_code },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_SendEmail_Request>(
"CTwoFactor_SendEmail_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_SendEmail_Request {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_SendEmail_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_SendEmail_Request::new)
}
}
impl ::protobuf::Clear for CTwoFactor_SendEmail_Request {
fn clear(&mut self) {
self.steamid = ::std::option::Option::None;
self.email_type = ::std::option::Option::None;
self.include_activation_code = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_SendEmail_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_SendEmail_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 CTwoFactor_SendEmail_Response {
#[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 CTwoFactor_SendEmail_Response {
fn default() -> &'a CTwoFactor_SendEmail_Response {
<CTwoFactor_SendEmail_Response as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_SendEmail_Response {
pub fn new() -> CTwoFactor_SendEmail_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CTwoFactor_SendEmail_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(())
}
#[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() -> CTwoFactor_SendEmail_Response {
CTwoFactor_SendEmail_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::<CTwoFactor_SendEmail_Response>(
"CTwoFactor_SendEmail_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_SendEmail_Response {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_SendEmail_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_SendEmail_Response::new)
}
}
impl ::protobuf::Clear for CTwoFactor_SendEmail_Response {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_SendEmail_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_SendEmail_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 CTwoFactor_FinalizeAddAuthenticator_Request {
steamid: ::std::option::Option<u64>,
authenticator_code: ::protobuf::SingularField<::std::string::String>,
authenticator_time: ::std::option::Option<u64>,
activation_code: ::protobuf::SingularField<::std::string::String>,
pub http_headers: ::protobuf::RepeatedField<::std::string::String>,
#[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 CTwoFactor_FinalizeAddAuthenticator_Request {
fn default() -> &'a CTwoFactor_FinalizeAddAuthenticator_Request {
<CTwoFactor_FinalizeAddAuthenticator_Request as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_FinalizeAddAuthenticator_Request {
pub fn new() -> CTwoFactor_FinalizeAddAuthenticator_Request {
::std::default::Default::default()
}
pub fn get_steamid(&self) -> u64 {
self.steamid.unwrap_or(0)
}
pub fn clear_steamid(&mut self) {
self.steamid = ::std::option::Option::None;
}
pub fn has_steamid(&self) -> bool {
self.steamid.is_some()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
pub fn get_authenticator_code(&self) -> &str {
match self.authenticator_code.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_authenticator_code(&mut self) {
self.authenticator_code.clear();
}
pub fn has_authenticator_code(&self) -> bool {
self.authenticator_code.is_some()
}
pub fn set_authenticator_code(&mut self, v: ::std::string::String) {
self.authenticator_code = ::protobuf::SingularField::some(v);
}
pub fn mut_authenticator_code(&mut self) -> &mut ::std::string::String {
if self.authenticator_code.is_none() {
self.authenticator_code.set_default();
}
self.authenticator_code.as_mut().unwrap()
}
pub fn take_authenticator_code(&mut self) -> ::std::string::String {
self.authenticator_code.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_authenticator_time(&self) -> u64 {
self.authenticator_time.unwrap_or(0)
}
pub fn clear_authenticator_time(&mut self) {
self.authenticator_time = ::std::option::Option::None;
}
pub fn has_authenticator_time(&self) -> bool {
self.authenticator_time.is_some()
}
pub fn set_authenticator_time(&mut self, v: u64) {
self.authenticator_time = ::std::option::Option::Some(v);
}
pub fn get_activation_code(&self) -> &str {
match self.activation_code.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_activation_code(&mut self) {
self.activation_code.clear();
}
pub fn has_activation_code(&self) -> bool {
self.activation_code.is_some()
}
pub fn set_activation_code(&mut self, v: ::std::string::String) {
self.activation_code = ::protobuf::SingularField::some(v);
}
pub fn mut_activation_code(&mut self) -> &mut ::std::string::String {
if self.activation_code.is_none() {
self.activation_code.set_default();
}
self.activation_code.as_mut().unwrap()
}
pub fn take_activation_code(&mut self) -> ::std::string::String {
self.activation_code.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_http_headers(&self) -> &[::std::string::String] {
&self.http_headers
}
pub fn clear_http_headers(&mut self) {
self.http_headers.clear();
}
pub fn set_http_headers(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.http_headers = v;
}
pub fn mut_http_headers(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.http_headers
}
pub fn take_http_headers(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.http_headers, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for CTwoFactor_FinalizeAddAuthenticator_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::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.steamid = ::std::option::Option::Some(tmp);
},
2 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.authenticator_code)?;
},
3 => {
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.authenticator_time = ::std::option::Option::Some(tmp);
},
4 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.activation_code)?;
},
5 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.http_headers)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.steamid {
my_size += 9;
}
if let Some(ref v) = self.authenticator_code.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
if let Some(v) = self.authenticator_time {
my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.activation_code.as_ref() {
my_size += ::protobuf::rt::string_size(4, &v);
}
for value in &self.http_headers {
my_size += ::protobuf::rt::string_size(5, &value);
};
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.steamid {
os.write_fixed64(1, v)?;
}
if let Some(ref v) = self.authenticator_code.as_ref() {
os.write_string(2, &v)?;
}
if let Some(v) = self.authenticator_time {
os.write_uint64(3, v)?;
}
if let Some(ref v) = self.activation_code.as_ref() {
os.write_string(4, &v)?;
}
for v in &self.http_headers {
os.write_string(5, &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() -> CTwoFactor_FinalizeAddAuthenticator_Request {
CTwoFactor_FinalizeAddAuthenticator_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::ProtobufTypeFixed64>(
"steamid",
|m: &CTwoFactor_FinalizeAddAuthenticator_Request| { &m.steamid },
|m: &mut CTwoFactor_FinalizeAddAuthenticator_Request| { &mut m.steamid },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"authenticator_code",
|m: &CTwoFactor_FinalizeAddAuthenticator_Request| { &m.authenticator_code },
|m: &mut CTwoFactor_FinalizeAddAuthenticator_Request| { &mut m.authenticator_code },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"authenticator_time",
|m: &CTwoFactor_FinalizeAddAuthenticator_Request| { &m.authenticator_time },
|m: &mut CTwoFactor_FinalizeAddAuthenticator_Request| { &mut m.authenticator_time },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"activation_code",
|m: &CTwoFactor_FinalizeAddAuthenticator_Request| { &m.activation_code },
|m: &mut CTwoFactor_FinalizeAddAuthenticator_Request| { &mut m.activation_code },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"http_headers",
|m: &CTwoFactor_FinalizeAddAuthenticator_Request| { &m.http_headers },
|m: &mut CTwoFactor_FinalizeAddAuthenticator_Request| { &mut m.http_headers },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_FinalizeAddAuthenticator_Request>(
"CTwoFactor_FinalizeAddAuthenticator_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_FinalizeAddAuthenticator_Request {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_FinalizeAddAuthenticator_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_FinalizeAddAuthenticator_Request::new)
}
}
impl ::protobuf::Clear for CTwoFactor_FinalizeAddAuthenticator_Request {
fn clear(&mut self) {
self.steamid = ::std::option::Option::None;
self.authenticator_code.clear();
self.authenticator_time = ::std::option::Option::None;
self.activation_code.clear();
self.http_headers.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_FinalizeAddAuthenticator_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_FinalizeAddAuthenticator_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 CTwoFactor_FinalizeAddAuthenticator_Response {
success: ::std::option::Option<bool>,
want_more: ::std::option::Option<bool>,
server_time: ::std::option::Option<u64>,
status: ::std::option::Option<i32>,
#[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 CTwoFactor_FinalizeAddAuthenticator_Response {
fn default() -> &'a CTwoFactor_FinalizeAddAuthenticator_Response {
<CTwoFactor_FinalizeAddAuthenticator_Response as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_FinalizeAddAuthenticator_Response {
pub fn new() -> CTwoFactor_FinalizeAddAuthenticator_Response {
::std::default::Default::default()
}
pub fn get_success(&self) -> bool {
self.success.unwrap_or(false)
}
pub fn clear_success(&mut self) {
self.success = ::std::option::Option::None;
}
pub fn has_success(&self) -> bool {
self.success.is_some()
}
pub fn set_success(&mut self, v: bool) {
self.success = ::std::option::Option::Some(v);
}
pub fn get_want_more(&self) -> bool {
self.want_more.unwrap_or(false)
}
pub fn clear_want_more(&mut self) {
self.want_more = ::std::option::Option::None;
}
pub fn has_want_more(&self) -> bool {
self.want_more.is_some()
}
pub fn set_want_more(&mut self, v: bool) {
self.want_more = ::std::option::Option::Some(v);
}
pub fn get_server_time(&self) -> u64 {
self.server_time.unwrap_or(0)
}
pub fn clear_server_time(&mut self) {
self.server_time = ::std::option::Option::None;
}
pub fn has_server_time(&self) -> bool {
self.server_time.is_some()
}
pub fn set_server_time(&mut self, v: u64) {
self.server_time = ::std::option::Option::Some(v);
}
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()
}
pub fn set_status(&mut self, v: i32) {
self.status = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CTwoFactor_FinalizeAddAuthenticator_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.success = ::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.want_more = ::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_uint64()?;
self.server_time = ::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.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(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.success {
my_size += 2;
}
if let Some(v) = self.want_more {
my_size += 2;
}
if let Some(v) = self.server_time {
my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.status {
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.success {
os.write_bool(1, v)?;
}
if let Some(v) = self.want_more {
os.write_bool(2, v)?;
}
if let Some(v) = self.server_time {
os.write_uint64(3, v)?;
}
if let Some(v) = self.status {
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() -> CTwoFactor_FinalizeAddAuthenticator_Response {
CTwoFactor_FinalizeAddAuthenticator_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>(
"success",
|m: &CTwoFactor_FinalizeAddAuthenticator_Response| { &m.success },
|m: &mut CTwoFactor_FinalizeAddAuthenticator_Response| { &mut m.success },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"want_more",
|m: &CTwoFactor_FinalizeAddAuthenticator_Response| { &m.want_more },
|m: &mut CTwoFactor_FinalizeAddAuthenticator_Response| { &mut m.want_more },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"server_time",
|m: &CTwoFactor_FinalizeAddAuthenticator_Response| { &m.server_time },
|m: &mut CTwoFactor_FinalizeAddAuthenticator_Response| { &mut m.server_time },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"status",
|m: &CTwoFactor_FinalizeAddAuthenticator_Response| { &m.status },
|m: &mut CTwoFactor_FinalizeAddAuthenticator_Response| { &mut m.status },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_FinalizeAddAuthenticator_Response>(
"CTwoFactor_FinalizeAddAuthenticator_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_FinalizeAddAuthenticator_Response {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_FinalizeAddAuthenticator_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_FinalizeAddAuthenticator_Response::new)
}
}
impl ::protobuf::Clear for CTwoFactor_FinalizeAddAuthenticator_Response {
fn clear(&mut self) {
self.success = ::std::option::Option::None;
self.want_more = ::std::option::Option::None;
self.server_time = ::std::option::Option::None;
self.status = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_FinalizeAddAuthenticator_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_FinalizeAddAuthenticator_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 CTwoFactor_RemoveAuthenticator_Request {
revocation_code: ::protobuf::SingularField<::std::string::String>,
revocation_reason: ::std::option::Option<u32>,
steamguard_scheme: ::std::option::Option<u32>,
remove_all_steamguard_cookies: ::std::option::Option<bool>,
#[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 CTwoFactor_RemoveAuthenticator_Request {
fn default() -> &'a CTwoFactor_RemoveAuthenticator_Request {
<CTwoFactor_RemoveAuthenticator_Request as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_RemoveAuthenticator_Request {
pub fn new() -> CTwoFactor_RemoveAuthenticator_Request {
::std::default::Default::default()
}
pub fn get_revocation_code(&self) -> &str {
match self.revocation_code.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_revocation_code(&mut self) {
self.revocation_code.clear();
}
pub fn has_revocation_code(&self) -> bool {
self.revocation_code.is_some()
}
pub fn set_revocation_code(&mut self, v: ::std::string::String) {
self.revocation_code = ::protobuf::SingularField::some(v);
}
pub fn mut_revocation_code(&mut self) -> &mut ::std::string::String {
if self.revocation_code.is_none() {
self.revocation_code.set_default();
}
self.revocation_code.as_mut().unwrap()
}
pub fn take_revocation_code(&mut self) -> ::std::string::String {
self.revocation_code.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_revocation_reason(&self) -> u32 {
self.revocation_reason.unwrap_or(0)
}
pub fn clear_revocation_reason(&mut self) {
self.revocation_reason = ::std::option::Option::None;
}
pub fn has_revocation_reason(&self) -> bool {
self.revocation_reason.is_some()
}
pub fn set_revocation_reason(&mut self, v: u32) {
self.revocation_reason = ::std::option::Option::Some(v);
}
pub fn get_steamguard_scheme(&self) -> u32 {
self.steamguard_scheme.unwrap_or(0)
}
pub fn clear_steamguard_scheme(&mut self) {
self.steamguard_scheme = ::std::option::Option::None;
}
pub fn has_steamguard_scheme(&self) -> bool {
self.steamguard_scheme.is_some()
}
pub fn set_steamguard_scheme(&mut self, v: u32) {
self.steamguard_scheme = ::std::option::Option::Some(v);
}
pub fn get_remove_all_steamguard_cookies(&self) -> bool {
self.remove_all_steamguard_cookies.unwrap_or(false)
}
pub fn clear_remove_all_steamguard_cookies(&mut self) {
self.remove_all_steamguard_cookies = ::std::option::Option::None;
}
pub fn has_remove_all_steamguard_cookies(&self) -> bool {
self.remove_all_steamguard_cookies.is_some()
}
pub fn set_remove_all_steamguard_cookies(&mut self, v: bool) {
self.remove_all_steamguard_cookies = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CTwoFactor_RemoveAuthenticator_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 {
2 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.revocation_code)?;
},
5 => {
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.revocation_reason = ::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_uint32()?;
self.steamguard_scheme = ::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_bool()?;
self.remove_all_steamguard_cookies = ::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(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.revocation_code.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
if let Some(v) = self.revocation_reason {
my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.steamguard_scheme {
my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.remove_all_steamguard_cookies {
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(ref v) = self.revocation_code.as_ref() {
os.write_string(2, &v)?;
}
if let Some(v) = self.revocation_reason {
os.write_uint32(5, v)?;
}
if let Some(v) = self.steamguard_scheme {
os.write_uint32(6, v)?;
}
if let Some(v) = self.remove_all_steamguard_cookies {
os.write_bool(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() -> CTwoFactor_RemoveAuthenticator_Request {
CTwoFactor_RemoveAuthenticator_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>(
"revocation_code",
|m: &CTwoFactor_RemoveAuthenticator_Request| { &m.revocation_code },
|m: &mut CTwoFactor_RemoveAuthenticator_Request| { &mut m.revocation_code },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"revocation_reason",
|m: &CTwoFactor_RemoveAuthenticator_Request| { &m.revocation_reason },
|m: &mut CTwoFactor_RemoveAuthenticator_Request| { &mut m.revocation_reason },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"steamguard_scheme",
|m: &CTwoFactor_RemoveAuthenticator_Request| { &m.steamguard_scheme },
|m: &mut CTwoFactor_RemoveAuthenticator_Request| { &mut m.steamguard_scheme },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"remove_all_steamguard_cookies",
|m: &CTwoFactor_RemoveAuthenticator_Request| { &m.remove_all_steamguard_cookies },
|m: &mut CTwoFactor_RemoveAuthenticator_Request| { &mut m.remove_all_steamguard_cookies },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_RemoveAuthenticator_Request>(
"CTwoFactor_RemoveAuthenticator_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_RemoveAuthenticator_Request {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_RemoveAuthenticator_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_RemoveAuthenticator_Request::new)
}
}
impl ::protobuf::Clear for CTwoFactor_RemoveAuthenticator_Request {
fn clear(&mut self) {
self.revocation_code.clear();
self.revocation_reason = ::std::option::Option::None;
self.steamguard_scheme = ::std::option::Option::None;
self.remove_all_steamguard_cookies = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_RemoveAuthenticator_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_RemoveAuthenticator_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 CTwoFactor_RemoveAuthenticator_Response {
success: ::std::option::Option<bool>,
server_time: ::std::option::Option<u64>,
revocation_attempts_remaining: ::std::option::Option<u32>,
#[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 CTwoFactor_RemoveAuthenticator_Response {
fn default() -> &'a CTwoFactor_RemoveAuthenticator_Response {
<CTwoFactor_RemoveAuthenticator_Response as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_RemoveAuthenticator_Response {
pub fn new() -> CTwoFactor_RemoveAuthenticator_Response {
::std::default::Default::default()
}
pub fn get_success(&self) -> bool {
self.success.unwrap_or(false)
}
pub fn clear_success(&mut self) {
self.success = ::std::option::Option::None;
}
pub fn has_success(&self) -> bool {
self.success.is_some()
}
pub fn set_success(&mut self, v: bool) {
self.success = ::std::option::Option::Some(v);
}
pub fn get_server_time(&self) -> u64 {
self.server_time.unwrap_or(0)
}
pub fn clear_server_time(&mut self) {
self.server_time = ::std::option::Option::None;
}
pub fn has_server_time(&self) -> bool {
self.server_time.is_some()
}
pub fn set_server_time(&mut self, v: u64) {
self.server_time = ::std::option::Option::Some(v);
}
pub fn get_revocation_attempts_remaining(&self) -> u32 {
self.revocation_attempts_remaining.unwrap_or(0)
}
pub fn clear_revocation_attempts_remaining(&mut self) {
self.revocation_attempts_remaining = ::std::option::Option::None;
}
pub fn has_revocation_attempts_remaining(&self) -> bool {
self.revocation_attempts_remaining.is_some()
}
pub fn set_revocation_attempts_remaining(&mut self, v: u32) {
self.revocation_attempts_remaining = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CTwoFactor_RemoveAuthenticator_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.success = ::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_uint64()?;
self.server_time = ::std::option::Option::Some(tmp);
},
5 => {
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.revocation_attempts_remaining = ::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(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.success {
my_size += 2;
}
if let Some(v) = self.server_time {
my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.revocation_attempts_remaining {
my_size += ::protobuf::rt::value_size(5, 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.success {
os.write_bool(1, v)?;
}
if let Some(v) = self.server_time {
os.write_uint64(3, v)?;
}
if let Some(v) = self.revocation_attempts_remaining {
os.write_uint32(5, 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() -> CTwoFactor_RemoveAuthenticator_Response {
CTwoFactor_RemoveAuthenticator_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>(
"success",
|m: &CTwoFactor_RemoveAuthenticator_Response| { &m.success },
|m: &mut CTwoFactor_RemoveAuthenticator_Response| { &mut m.success },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"server_time",
|m: &CTwoFactor_RemoveAuthenticator_Response| { &m.server_time },
|m: &mut CTwoFactor_RemoveAuthenticator_Response| { &mut m.server_time },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"revocation_attempts_remaining",
|m: &CTwoFactor_RemoveAuthenticator_Response| { &m.revocation_attempts_remaining },
|m: &mut CTwoFactor_RemoveAuthenticator_Response| { &mut m.revocation_attempts_remaining },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_RemoveAuthenticator_Response>(
"CTwoFactor_RemoveAuthenticator_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_RemoveAuthenticator_Response {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_RemoveAuthenticator_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_RemoveAuthenticator_Response::new)
}
}
impl ::protobuf::Clear for CTwoFactor_RemoveAuthenticator_Response {
fn clear(&mut self) {
self.success = ::std::option::Option::None;
self.server_time = ::std::option::Option::None;
self.revocation_attempts_remaining = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_RemoveAuthenticator_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_RemoveAuthenticator_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 CTwoFactor_CreateEmergencyCodes_Request {
code: ::protobuf::SingularField<::std::string::String>,
#[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 CTwoFactor_CreateEmergencyCodes_Request {
fn default() -> &'a CTwoFactor_CreateEmergencyCodes_Request {
<CTwoFactor_CreateEmergencyCodes_Request as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_CreateEmergencyCodes_Request {
pub fn new() -> CTwoFactor_CreateEmergencyCodes_Request {
::std::default::Default::default()
}
pub fn get_code(&self) -> &str {
match self.code.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_code(&mut self) {
self.code.clear();
}
pub fn has_code(&self) -> bool {
self.code.is_some()
}
pub fn set_code(&mut self, v: ::std::string::String) {
self.code = ::protobuf::SingularField::some(v);
}
pub fn mut_code(&mut self) -> &mut ::std::string::String {
if self.code.is_none() {
self.code.set_default();
}
self.code.as_mut().unwrap()
}
pub fn take_code(&mut self) -> ::std::string::String {
self.code.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for CTwoFactor_CreateEmergencyCodes_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.code)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.code.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.code.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() -> CTwoFactor_CreateEmergencyCodes_Request {
CTwoFactor_CreateEmergencyCodes_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>(
"code",
|m: &CTwoFactor_CreateEmergencyCodes_Request| { &m.code },
|m: &mut CTwoFactor_CreateEmergencyCodes_Request| { &mut m.code },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_CreateEmergencyCodes_Request>(
"CTwoFactor_CreateEmergencyCodes_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_CreateEmergencyCodes_Request {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_CreateEmergencyCodes_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_CreateEmergencyCodes_Request::new)
}
}
impl ::protobuf::Clear for CTwoFactor_CreateEmergencyCodes_Request {
fn clear(&mut self) {
self.code.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_CreateEmergencyCodes_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_CreateEmergencyCodes_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 CTwoFactor_CreateEmergencyCodes_Response {
pub codes: ::protobuf::RepeatedField<::std::string::String>,
#[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 CTwoFactor_CreateEmergencyCodes_Response {
fn default() -> &'a CTwoFactor_CreateEmergencyCodes_Response {
<CTwoFactor_CreateEmergencyCodes_Response as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_CreateEmergencyCodes_Response {
pub fn new() -> CTwoFactor_CreateEmergencyCodes_Response {
::std::default::Default::default()
}
pub fn get_codes(&self) -> &[::std::string::String] {
&self.codes
}
pub fn clear_codes(&mut self) {
self.codes.clear();
}
pub fn set_codes(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.codes = v;
}
pub fn mut_codes(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.codes
}
pub fn take_codes(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.codes, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for CTwoFactor_CreateEmergencyCodes_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_repeated_string_into(wire_type, is, &mut self.codes)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
for value in &self.codes {
my_size += ::protobuf::rt::string_size(1, &value);
};
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<()> {
for v in &self.codes {
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() -> CTwoFactor_CreateEmergencyCodes_Response {
CTwoFactor_CreateEmergencyCodes_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_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"codes",
|m: &CTwoFactor_CreateEmergencyCodes_Response| { &m.codes },
|m: &mut CTwoFactor_CreateEmergencyCodes_Response| { &mut m.codes },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_CreateEmergencyCodes_Response>(
"CTwoFactor_CreateEmergencyCodes_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_CreateEmergencyCodes_Response {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_CreateEmergencyCodes_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_CreateEmergencyCodes_Response::new)
}
}
impl ::protobuf::Clear for CTwoFactor_CreateEmergencyCodes_Response {
fn clear(&mut self) {
self.codes.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_CreateEmergencyCodes_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_CreateEmergencyCodes_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 CTwoFactor_DestroyEmergencyCodes_Request {
steamid: ::std::option::Option<u64>,
#[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 CTwoFactor_DestroyEmergencyCodes_Request {
fn default() -> &'a CTwoFactor_DestroyEmergencyCodes_Request {
<CTwoFactor_DestroyEmergencyCodes_Request as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_DestroyEmergencyCodes_Request {
pub fn new() -> CTwoFactor_DestroyEmergencyCodes_Request {
::std::default::Default::default()
}
pub fn get_steamid(&self) -> u64 {
self.steamid.unwrap_or(0)
}
pub fn clear_steamid(&mut self) {
self.steamid = ::std::option::Option::None;
}
pub fn has_steamid(&self) -> bool {
self.steamid.is_some()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CTwoFactor_DestroyEmergencyCodes_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::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.steamid = ::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(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.steamid {
my_size += 9;
}
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.steamid {
os.write_fixed64(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() -> CTwoFactor_DestroyEmergencyCodes_Request {
CTwoFactor_DestroyEmergencyCodes_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::ProtobufTypeFixed64>(
"steamid",
|m: &CTwoFactor_DestroyEmergencyCodes_Request| { &m.steamid },
|m: &mut CTwoFactor_DestroyEmergencyCodes_Request| { &mut m.steamid },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_DestroyEmergencyCodes_Request>(
"CTwoFactor_DestroyEmergencyCodes_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_DestroyEmergencyCodes_Request {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_DestroyEmergencyCodes_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_DestroyEmergencyCodes_Request::new)
}
}
impl ::protobuf::Clear for CTwoFactor_DestroyEmergencyCodes_Request {
fn clear(&mut self) {
self.steamid = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_DestroyEmergencyCodes_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_DestroyEmergencyCodes_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 CTwoFactor_DestroyEmergencyCodes_Response {
#[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 CTwoFactor_DestroyEmergencyCodes_Response {
fn default() -> &'a CTwoFactor_DestroyEmergencyCodes_Response {
<CTwoFactor_DestroyEmergencyCodes_Response as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_DestroyEmergencyCodes_Response {
pub fn new() -> CTwoFactor_DestroyEmergencyCodes_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CTwoFactor_DestroyEmergencyCodes_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(())
}
#[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() -> CTwoFactor_DestroyEmergencyCodes_Response {
CTwoFactor_DestroyEmergencyCodes_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::<CTwoFactor_DestroyEmergencyCodes_Response>(
"CTwoFactor_DestroyEmergencyCodes_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_DestroyEmergencyCodes_Response {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_DestroyEmergencyCodes_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_DestroyEmergencyCodes_Response::new)
}
}
impl ::protobuf::Clear for CTwoFactor_DestroyEmergencyCodes_Response {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_DestroyEmergencyCodes_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_DestroyEmergencyCodes_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 CTwoFactor_ValidateToken_Request {
code: ::protobuf::SingularField<::std::string::String>,
#[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 CTwoFactor_ValidateToken_Request {
fn default() -> &'a CTwoFactor_ValidateToken_Request {
<CTwoFactor_ValidateToken_Request as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_ValidateToken_Request {
pub fn new() -> CTwoFactor_ValidateToken_Request {
::std::default::Default::default()
}
pub fn get_code(&self) -> &str {
match self.code.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_code(&mut self) {
self.code.clear();
}
pub fn has_code(&self) -> bool {
self.code.is_some()
}
pub fn set_code(&mut self, v: ::std::string::String) {
self.code = ::protobuf::SingularField::some(v);
}
pub fn mut_code(&mut self) -> &mut ::std::string::String {
if self.code.is_none() {
self.code.set_default();
}
self.code.as_mut().unwrap()
}
pub fn take_code(&mut self) -> ::std::string::String {
self.code.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for CTwoFactor_ValidateToken_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.code)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.code.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.code.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() -> CTwoFactor_ValidateToken_Request {
CTwoFactor_ValidateToken_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>(
"code",
|m: &CTwoFactor_ValidateToken_Request| { &m.code },
|m: &mut CTwoFactor_ValidateToken_Request| { &mut m.code },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_ValidateToken_Request>(
"CTwoFactor_ValidateToken_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_ValidateToken_Request {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_ValidateToken_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_ValidateToken_Request::new)
}
}
impl ::protobuf::Clear for CTwoFactor_ValidateToken_Request {
fn clear(&mut self) {
self.code.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_ValidateToken_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_ValidateToken_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 CTwoFactor_ValidateToken_Response {
valid: ::std::option::Option<bool>,
#[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 CTwoFactor_ValidateToken_Response {
fn default() -> &'a CTwoFactor_ValidateToken_Response {
<CTwoFactor_ValidateToken_Response as ::protobuf::Message>::default_instance()
}
}
impl CTwoFactor_ValidateToken_Response {
pub fn new() -> CTwoFactor_ValidateToken_Response {
::std::default::Default::default()
}
pub fn get_valid(&self) -> bool {
self.valid.unwrap_or(false)
}
pub fn clear_valid(&mut self) {
self.valid = ::std::option::Option::None;
}
pub fn has_valid(&self) -> bool {
self.valid.is_some()
}
pub fn set_valid(&mut self, v: bool) {
self.valid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CTwoFactor_ValidateToken_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.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(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.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.valid {
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() -> CTwoFactor_ValidateToken_Response {
CTwoFactor_ValidateToken_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>(
"valid",
|m: &CTwoFactor_ValidateToken_Response| { &m.valid },
|m: &mut CTwoFactor_ValidateToken_Response| { &mut m.valid },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_ValidateToken_Response>(
"CTwoFactor_ValidateToken_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CTwoFactor_ValidateToken_Response {
static instance: ::protobuf::rt::LazyV2<CTwoFactor_ValidateToken_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CTwoFactor_ValidateToken_Response::new)
}
}
impl ::protobuf::Clear for CTwoFactor_ValidateToken_Response {
fn clear(&mut self) {
self.valid = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CTwoFactor_ValidateToken_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CTwoFactor_ValidateToken_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n)steammessages_twofactor.steamclient.proto\x1a,steammessages_unified_b\
ase.steamclient.proto\"I\n\x19CTwoFactor_Status_Request\x12,\n\x07steami\
d\x18\x01\x20\x01(\x06R\x07steamidB\x12\x82\xb5\x18\x0esteamid\x20to\x20\
use\"\xb1\t\n\x1aCTwoFactor_Status_Response\x12-\n\x05state\x18\x01\x20\
\x01(\rR\x05stateB\x17\x82\xb5\x18\x13Authenticator\x20state\x12Q\n\x13i\
nactivation_reason\x18\x02\x20\x01(\rR\x12inactivationReasonB\x20\x82\
\xb5\x18\x1cInactivation\x20reason\x20(if\x20any)\x12H\n\x12authenticato\
r_type\x18\x03\x20\x01(\rR\x11authenticatorTypeB\x19\x82\xb5\x18\x15Type\
\x20of\x20authenticator\x12b\n\x15authenticator_allowed\x18\x04\x20\x01(\
\x08R\x14authenticatorAllowedB-\x82\xb5\x18)Account\x20allowed\x20to\x20\
have\x20an\x20authenticator?\x12M\n\x11steamguard_scheme\x18\x05\x20\x01\
(\rR\x10steamguardSchemeB\x20\x82\xb5\x18\x1cSteam\x20Guard\x20scheme\
\x20in\x20effect\x12K\n\ttoken_gid\x18\x06\x20\x01(\tR\x08tokenGidB.\x82\
\xb5\x18*String\x20rep\x20of\x20token\x20GID\x20assigned\x20by\x20server\
\x12R\n\x0femail_validated\x18\x07\x20\x01(\x08R\x0eemailValidatedB)\x82\
\xb5\x18%Account\x20has\x20verified\x20email\x20capability\x12Q\n\x11dev\
ice_identifier\x18\x08\x20\x01(\tR\x10deviceIdentifierB$\x82\xb5\x18\x20\
Authenticator\x20(phone)\x20identifier\x12A\n\x0ctime_created\x18\t\x20\
\x01(\rR\x0btimeCreatedB\x1e\x82\xb5\x18\x1aWhen\x20the\x20token\x20was\
\x20created\x12t\n\x1drevocation_attempts_remaining\x18\n\x20\x01(\rR\
\x1brevocationAttemptsRemainingB0\x82\xb5\x18,Number\x20of\x20revocation\
\x20code\x20attempts\x20remaining\x12o\n\x10classified_agent\x18\x0b\x20\
\x01(\tR\x0fclassifiedAgentBD\x82\xb5\x18@Agent\x20that\x20added\x20the\
\x20authenticator\x20(e.g.,\x20ios\x20/\x20android\x20/\x20other)\x12\
\x83\x01\n\x1callow_external_authenticator\x18\x0c\x20\x01(\x08R\x1aallo\
wExternalAuthenticatorBA\x82\xb5\x18=Allow\x20a\x20third-party\x20authen\
ticator\x20(in\x20addition\x20to\x20two-factor)\x12p\n\x10time_transferr\
ed\x18\r\x20\x01(\rR\x0ftimeTransferredBE\x82\xb5\x18AWhen\x20the\x20tok\
en\x20was\x20transferred\x20from\x20another\x20device,\x20if\x20applicab\
le\"\x9a\x04\n#CTwoFactor_AddAuthenticator_Request\x12,\n\x07steamid\x18\
\x01\x20\x01(\x06R\x07steamidB\x12\x82\xb5\x18\x0esteamid\x20to\x20use\
\x12M\n\x12authenticator_time\x18\x02\x20\x01(\x04R\x11authenticatorTime\
B\x1e\x82\xb5\x18\x1aCurrent\x20authenticator\x20time\x12M\n\rserial_num\
ber\x18\x03\x20\x01(\x06R\x0cserialNumberB(\x82\xb5\x18$locally\x20compu\
ted\x20serial\x20(deprecated)\x12E\n\x12authenticator_type\x18\x04\x20\
\x01(\rR\x11authenticatorTypeB\x16\x82\xb5\x18\x12Authenticator\x20type\
\x12I\n\x11device_identifier\x18\x05\x20\x01(\tR\x10deviceIdentifierB\
\x1c\x82\xb5\x18\x18Authenticator\x20identifier\x12M\n\x0csms_phone_id\
\x18\x06\x20\x01(\tR\nsmsPhoneIdB+\x82\xb5\x18'ID\x20of\x20phone\x20to\
\x20use\x20for\x20SMS\x20verification\x12F\n\x0chttp_headers\x18\x07\x20\
\x03(\tR\x0bhttpHeadersB#\x82\xb5\x18\x1fHTTP\x20headers\x20alternating\
\x20by\x20K/V\"\xe8\x05\n$CTwoFactor_AddAuthenticator_Response\x12W\n\rs\
hared_secret\x18\x01\x20\x01(\x0cR\x0csharedSecretB2\x82\xb5\x18.Shared\
\x20secret\x20between\x20server\x20and\x20authenticator\x12W\n\rserial_n\
umber\x18\x02\x20\x01(\x06R\x0cserialNumberB2\x82\xb5\x18.Authenticator\
\x20serial\x20number\x20(unique\x20per\x20token)\x12N\n\x0frevocation_co\
de\x18\x03\x20\x01(\tR\x0erevocationCodeB%\x82\xb5\x18!code\x20used\x20t\
o\x20revoke\x20authenticator\x120\n\x03uri\x18\x04\x20\x01(\tR\x03uriB\
\x1e\x82\xb5\x18\x1aURI\x20for\x20QR\x20code\x20generation\x128\n\x0bser\
ver_time\x18\x05\x20\x01(\x04R\nserverTimeB\x17\x82\xb5\x18\x13Current\
\x20server\x20time\x12N\n\x0caccount_name\x18\x06\x20\x01(\tR\x0baccount\
NameB+\x82\xb5\x18'Account\x20name\x20to\x20display\x20on\x20token\x20cl\
ient\x12=\n\ttoken_gid\x18\x07\x20\x01(\tR\x08tokenGidB\x20\x82\xb5\x18\
\x1cToken\x20GID\x20assigned\x20by\x20server\x12f\n\x0fidentity_secret\
\x18\x08\x20\x01(\x0cR\x0eidentitySecretB=\x82\xb5\x189Secret\x20used\
\x20for\x20identity\x20attestation\x20(e.g.,\x20for\x20eventing)\x122\n\
\x08secret_1\x18\t\x20\x01(\x0cR\x07secret1B\x17\x82\xb5\x18\x13Spare\
\x20shared\x20secret\x12'\n\x06status\x18\n\x20\x01(\x05R\x06statusB\x0f\
\x82\xb5\x18\x0bResult\x20code\"\x88\x02\n\x1cCTwoFactor_SendEmail_Reque\
st\x12,\n\x07steamid\x18\x01\x20\x01(\x06R\x07steamidB\x12\x82\xb5\x18\
\x0eSteamid\x20to\x20use\x12Q\n\nemail_type\x18\x02\x20\x01(\rR\temailTy\
peB2\x82\xb5\x18.Type\x20of\x20email\x20to\x20send\x20(ETwoFactorEmailTy\
pe::*)\x12g\n\x17include_activation_code\x18\x03\x20\x01(\x08R\x15includ\
eActivationCodeB/\x82\xb5\x18+Include\x20activation\x20code\x20in\x20ema\
il\x20parameters\"\x1f\n\x1dCTwoFactor_SendEmail_Response\"\x8f\x03\n+CT\
woFactor_FinalizeAddAuthenticator_Request\x12,\n\x07steamid\x18\x01\x20\
\x01(\x06R\x07steamidB\x12\x82\xb5\x18\x0esteamid\x20to\x20use\x12D\n\
\x12authenticator_code\x18\x02\x20\x01(\tR\x11authenticatorCodeB\x15\x82\
\xb5\x18\x11Current\x20auth\x20code\x12M\n\x12authenticator_time\x18\x03\
\x20\x01(\x04R\x11authenticatorTimeB\x1e\x82\xb5\x18\x1aCurrent\x20authe\
nticator\x20time\x12U\n\x0factivation_code\x18\x04\x20\x01(\tR\x0eactiva\
tionCodeB,\x82\xb5\x18(Activation\x20code\x20from\x20out-of-band\x20mess\
age\x12F\n\x0chttp_headers\x18\x05\x20\x03(\tR\x0bhttpHeadersB#\x82\xb5\
\x18\x1fHTTP\x20headers\x20alternating\x20by\x20K/V\"\x90\x02\n,CTwoFact\
or_FinalizeAddAuthenticator_Response\x12C\n\x07success\x18\x01\x20\x01(\
\x08R\x07successB)\x82\xb5\x18%True\x20if\x20succeeded,\x20or\x20want\
\x20more\x20tries\x128\n\twant_more\x18\x02\x20\x01(\x08R\x08wantMoreB\
\x1b\x82\xb5\x18\x17True\x20if\x20want\x20more\x20tries\x128\n\x0bserver\
_time\x18\x03\x20\x01(\x04R\nserverTimeB\x17\x82\xb5\x18\x13Current\x20s\
erver\x20time\x12'\n\x06status\x18\x04\x20\x01(\x05R\x06statusB\x0f\x82\
\xb5\x18\x0bResult\x20code\"\x9b\x03\n&CTwoFactor_RemoveAuthenticator_Re\
quest\x12L\n\x0frevocation_code\x18\x02\x20\x01(\tR\x0erevocationCodeB#\
\x82\xb5\x18\x1fPassword\x20needed\x20to\x20remove\x20token\x12Z\n\x11re\
vocation_reason\x18\x05\x20\x01(\rR\x10revocationReasonB-\x82\xb5\x18)Re\
ason\x20the\x20authenticator\x20is\x20being\x20removed\x12a\n\x11steamgu\
ard_scheme\x18\x06\x20\x01(\rR\x10steamguardSchemeB4\x82\xb5\x180Type\
\x20of\x20Steam\x20Guard\x20to\x20use\x20once\x20token\x20is\x20removed\
\x12d\n\x1dremove_all_steamguard_cookies\x18\x07\x20\x01(\x08R\x1aremove\
AllSteamguardCookiesB!\x82\xb5\x18\x1dRemove\x20all\x20steamguard\x20coo\
kies\"\xb0\x02\n'CTwoFactor_RemoveAuthenticator_Response\x12U\n\x07succe\
ss\x18\x01\x20\x01(\x08R\x07successB;\x82\xb5\x187True\x20if\x20request\
\x20succeeeded.\x20The\x20mobile\x20app\x20checks\x20this.\x128\n\x0bser\
ver_time\x18\x03\x20\x01(\x04R\nserverTimeB\x17\x82\xb5\x18\x13Current\
\x20server\x20time\x12t\n\x1drevocation_attempts_remaining\x18\x05\x20\
\x01(\rR\x1brevocationAttemptsRemainingB0\x82\xb5\x18,Number\x20of\x20re\
vocation\x20code\x20attempts\x20remaining\"=\n'CTwoFactor_CreateEmergenc\
yCodes_Request\x12\x12\n\x04code\x18\x01\x20\x01(\tR\x04code\"U\n(CTwoFa\
ctor_CreateEmergencyCodes_Response\x12)\n\x05codes\x18\x01\x20\x03(\tR\
\x05codesB\x13\x82\xb5\x18\x0fEmergency\x20codes\"X\n(CTwoFactor_Destroy\
EmergencyCodes_Request\x12,\n\x07steamid\x18\x01\x20\x01(\x06R\x07steami\
dB\x12\x82\xb5\x18\x0esteamid\x20to\x20use\"+\n)CTwoFactor_DestroyEmerge\
ncyCodes_Response\"L\n\x20CTwoFactor_ValidateToken_Request\x12(\n\x04cod\
e\x18\x01\x20\x01(\tR\x04codeB\x14\x82\xb5\x18\x10code\x20to\x20validate\
\"S\n!CTwoFactor_ValidateToken_Response\x12.\n\x05valid\x18\x01\x20\x01(\
\x08R\x05validB\x18\x82\xb5\x18\x14result\x20of\x20validation2\x84\n\n\t\
TwoFactor\x12\x8c\x01\n\x0bQueryStatus\x12\x1a.CTwoFactor_Status_Request\
\x1a\x1b.CTwoFactor_Status_Response\"D\x82\xb5\x18@Get\x20two-factor\x20\
authentication\x20settings\x20for\x20the\x20logged-in\x20account\x12\x9a\
\x01\n\x10AddAuthenticator\x12$.CTwoFactor_AddAuthenticator_Request\x1a%\
.CTwoFactor_AddAuthenticator_Response\"9\x82\xb5\x185Add\x20two-factor\
\x20authenticator\x20to\x20the\x20logged-in\x20account\x12i\n\tSendEmail\
\x12\x1d.CTwoFactor_SendEmail_Request\x1a\x1e.CTwoFactor_SendEmail_Respo\
nse\"\x1d\x82\xb5\x18\x19Send\x20email\x20to\x20the\x20account\x12\xc1\
\x01\n\x18FinalizeAddAuthenticator\x12,.CTwoFactor_FinalizeAddAuthentica\
tor_Request\x1a-.CTwoFactor_FinalizeAddAuthenticator_Response\"H\x82\xb5\
\x18DFinalize\x20two-factor\x20authentication\x20addition\x20to\x20the\
\x20logged-in\x20account\x12\xb2\x01\n\x13RemoveAuthenticator\x12'.CTwoF\
actor_RemoveAuthenticator_Request\x1a(.CTwoFactor_RemoveAuthenticator_Re\
sponse\"H\x82\xb5\x18DRemove\x20two-factor\x20authentication\x20addition\
\x20from\x20the\x20logged-in\x20account\x12\x97\x01\n\x14CreateEmergency\
Codes\x12(.CTwoFactor_CreateEmergencyCodes_Request\x1a).CTwoFactor_Creat\
eEmergencyCodes_Response\"*\x82\xb5\x18&Generate\x20emergency\x20authent\
icator\x20codes\x12\xa9\x01\n\x15DestroyEmergencyCodes\x12).CTwoFactor_D\
estroyEmergencyCodes_Request\x1a*.CTwoFactor_DestroyEmergencyCodes_Respo\
nse\"9\x82\xb5\x185Destroy\x20emergency\x20authenticator\x20codes\x20for\
\x20the\x20account\x12z\n\rValidateToken\x12!.CTwoFactor_ValidateToken_R\
equest\x1a\".CTwoFactor_ValidateToken_Response\"\"\x82\xb5\x18\x1eValida\
te\x20(and\x20consume)\x20a\x20token\x1a%\x82\xb5\x18!Two\x20Factor\x20A\
uthentication\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()
})
}