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

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

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

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

//! Generated file from `steammessages_twofactor.steamclient.proto`
// Generated for lite runtime

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

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

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

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

    // optional uint64 sender_time = 1;

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

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

    pub fn has_sender_time(&self) -> bool {
        self.sender_time.is_some()
    }

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.sender_time = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.sender_time {
            os.write_uint64(1, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

// @@protoc_insertion_point(message:CTwoFactor_Time_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CTwoFactor_Time_Response {
    // message fields
    // @@protoc_insertion_point(field:CTwoFactor_Time_Response.server_time)
    pub server_time: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CTwoFactor_Time_Response.skew_tolerance_seconds)
    pub skew_tolerance_seconds: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CTwoFactor_Time_Response.large_time_jink)
    pub large_time_jink: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CTwoFactor_Time_Response.probe_frequency_seconds)
    pub probe_frequency_seconds: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CTwoFactor_Time_Response.adjusted_time_probe_frequency_seconds)
    pub adjusted_time_probe_frequency_seconds: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CTwoFactor_Time_Response.hint_probe_frequency_seconds)
    pub hint_probe_frequency_seconds: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CTwoFactor_Time_Response.sync_timeout)
    pub sync_timeout: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CTwoFactor_Time_Response.try_again_seconds)
    pub try_again_seconds: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CTwoFactor_Time_Response.max_attempts)
    pub max_attempts: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CTwoFactor_Time_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint64 server_time = 1;

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

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

    // optional uint64 skew_tolerance_seconds = 2;

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

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

    pub fn has_skew_tolerance_seconds(&self) -> bool {
        self.skew_tolerance_seconds.is_some()
    }

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

    // optional uint64 large_time_jink = 3;

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

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

    pub fn has_large_time_jink(&self) -> bool {
        self.large_time_jink.is_some()
    }

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

    // optional uint32 probe_frequency_seconds = 4;

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

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

    pub fn has_probe_frequency_seconds(&self) -> bool {
        self.probe_frequency_seconds.is_some()
    }

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

    // optional uint32 adjusted_time_probe_frequency_seconds = 5;

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

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

    pub fn has_adjusted_time_probe_frequency_seconds(&self) -> bool {
        self.adjusted_time_probe_frequency_seconds.is_some()
    }

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

    // optional uint32 hint_probe_frequency_seconds = 6;

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

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

    pub fn has_hint_probe_frequency_seconds(&self) -> bool {
        self.hint_probe_frequency_seconds.is_some()
    }

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

    // optional uint32 sync_timeout = 7;

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

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

    pub fn has_sync_timeout(&self) -> bool {
        self.sync_timeout.is_some()
    }

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

    // optional uint32 try_again_seconds = 8;

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

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

    pub fn has_try_again_seconds(&self) -> bool {
        self.try_again_seconds.is_some()
    }

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

    // optional uint32 max_attempts = 9;

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

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

    pub fn has_max_attempts(&self) -> bool {
        self.max_attempts.is_some()
    }

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.server_time = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.skew_tolerance_seconds = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.large_time_jink = ::std::option::Option::Some(is.read_uint64()?);
                },
                32 => {
                    self.probe_frequency_seconds = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.adjusted_time_probe_frequency_seconds = ::std::option::Option::Some(is.read_uint32()?);
                },
                48 => {
                    self.hint_probe_frequency_seconds = ::std::option::Option::Some(is.read_uint32()?);
                },
                56 => {
                    self.sync_timeout = ::std::option::Option::Some(is.read_uint32()?);
                },
                64 => {
                    self.try_again_seconds = ::std::option::Option::Some(is.read_uint32()?);
                },
                72 => {
                    self.max_attempts = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.server_time {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.skew_tolerance_seconds {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.large_time_jink {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
        }
        if let Some(v) = self.probe_frequency_seconds {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.adjusted_time_probe_frequency_seconds {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.hint_probe_frequency_seconds {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.sync_timeout {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.try_again_seconds {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, v);
        }
        if let Some(v) = self.max_attempts {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.server_time {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.skew_tolerance_seconds {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.large_time_jink {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.probe_frequency_seconds {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.adjusted_time_probe_frequency_seconds {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.hint_probe_frequency_seconds {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.sync_timeout {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.try_again_seconds {
            os.write_uint32(8, v)?;
        }
        if let Some(v) = self.max_attempts {
            os.write_uint32(9, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.server_time = ::std::option::Option::None;
        self.skew_tolerance_seconds = ::std::option::Option::None;
        self.large_time_jink = ::std::option::Option::None;
        self.probe_frequency_seconds = ::std::option::Option::None;
        self.adjusted_time_probe_frequency_seconds = ::std::option::Option::None;
        self.hint_probe_frequency_seconds = ::std::option::Option::None;
        self.sync_timeout = ::std::option::Option::None;
        self.try_again_seconds = ::std::option::Option::None;
        self.max_attempts = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CTwoFactor_Time_Response {
        static instance: CTwoFactor_Time_Response = CTwoFactor_Time_Response {
            server_time: ::std::option::Option::None,
            skew_tolerance_seconds: ::std::option::Option::None,
            large_time_jink: ::std::option::Option::None,
            probe_frequency_seconds: ::std::option::Option::None,
            adjusted_time_probe_frequency_seconds: ::std::option::Option::None,
            hint_probe_frequency_seconds: ::std::option::Option::None,
            sync_timeout: ::std::option::Option::None,
            try_again_seconds: ::std::option::Option::None,
            max_attempts: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional fixed64 steamid = 1;

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

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

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

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

    // optional .ETwoFactorStatusFieldFlag include = 2;

    pub fn include(&self) -> ETwoFactorStatusFieldFlag {
        match self.include {
            Some(e) => e.enum_value_or(ETwoFactorStatusFieldFlag::k_ETwoFactorStatusFieldFlag_None),
            None => ETwoFactorStatusFieldFlag::k_ETwoFactorStatusFieldFlag_None,
        }
    }

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

    pub fn has_include(&self) -> bool {
        self.include.is_some()
    }

    // Param is passed by value, moved
    pub fn set_include(&mut self, v: ETwoFactorStatusFieldFlag) {
        self.include = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }
}

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                9 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                16 => {
                    self.include = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.include {
            os.write_enum(2, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

// @@protoc_insertion_point(message:CTwoFactor_UsageEvent)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CTwoFactor_UsageEvent {
    // message fields
    // @@protoc_insertion_point(field:CTwoFactor_UsageEvent.time)
    pub time: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CTwoFactor_UsageEvent.usage_type)
    pub usage_type: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<ETwoFactorUsageType>>,
    // @@protoc_insertion_point(field:CTwoFactor_UsageEvent.confirmation_type)
    pub confirmation_type: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CTwoFactor_UsageEvent.confirmation_action)
    pub confirmation_action: ::std::option::Option<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:CTwoFactor_UsageEvent.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 time = 1;

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

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

    pub fn has_time(&self) -> bool {
        self.time.is_some()
    }

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

    // optional .ETwoFactorUsageType usage_type = 2;

    pub fn usage_type(&self) -> ETwoFactorUsageType {
        match self.usage_type {
            Some(e) => e.enum_value_or(ETwoFactorUsageType::k_ETwoFactorUsageType_Unknown),
            None => ETwoFactorUsageType::k_ETwoFactorUsageType_Unknown,
        }
    }

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

    pub fn has_usage_type(&self) -> bool {
        self.usage_type.is_some()
    }

    // Param is passed by value, moved
    pub fn set_usage_type(&mut self, v: ETwoFactorUsageType) {
        self.usage_type = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional int32 confirmation_type = 3;

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

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

    pub fn has_confirmation_type(&self) -> bool {
        self.confirmation_type.is_some()
    }

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

    // optional int32 confirmation_action = 4;

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

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

    pub fn has_confirmation_action(&self) -> bool {
        self.confirmation_action.is_some()
    }

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.time = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.usage_type = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                24 => {
                    self.confirmation_type = ::std::option::Option::Some(is.read_int32()?);
                },
                32 => {
                    self.confirmation_action = ::std::option::Option::Some(is.read_int32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.time {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.usage_type {
            os.write_enum(2, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.confirmation_type {
            os.write_int32(3, v)?;
        }
        if let Some(v) = self.confirmation_action {
            os.write_int32(4, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.time = ::std::option::Option::None;
        self.usage_type = ::std::option::Option::None;
        self.confirmation_type = ::std::option::Option::None;
        self.confirmation_action = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CTwoFactor_UsageEvent {
        static instance: CTwoFactor_UsageEvent = CTwoFactor_UsageEvent {
            time: ::std::option::Option::None,
            usage_type: ::std::option::Option::None,
            confirmation_type: ::std::option::Option::None,
            confirmation_action: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CTwoFactor_Status_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CTwoFactor_Status_Response {
    // message fields
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.state)
    pub state: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.inactivation_reason)
    pub inactivation_reason: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.authenticator_type)
    pub authenticator_type: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.authenticator_allowed)
    pub authenticator_allowed: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.steamguard_scheme)
    pub steamguard_scheme: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.token_gid)
    pub token_gid: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.email_validated)
    pub email_validated: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.device_identifier)
    pub device_identifier: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.time_created)
    pub time_created: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.revocation_attempts_remaining)
    pub revocation_attempts_remaining: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.classified_agent)
    pub classified_agent: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.allow_external_authenticator)
    pub allow_external_authenticator: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.time_transferred)
    pub time_transferred: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.version)
    pub version: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.last_seen_auth_token_id)
    pub last_seen_auth_token_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CTwoFactor_Status_Response.usages)
    pub usages: ::std::vec::Vec<CTwoFactor_UsageEvent>,
    // special fields
    // @@protoc_insertion_point(special_field:CTwoFactor_Status_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 state = 1;

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

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

    // optional uint32 inactivation_reason = 2;

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

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

    // optional uint32 authenticator_type = 3;

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

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

    // optional bool authenticator_allowed = 4;

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

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

    // optional uint32 steamguard_scheme = 5;

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

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

    // optional string token_gid = 6;

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

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

    pub fn has_token_gid(&self) -> bool {
        self.token_gid.is_some()
    }

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

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

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

    // optional bool email_validated = 7;

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

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

    // optional string device_identifier = 8;

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

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

    pub fn has_device_identifier(&self) -> bool {
        self.device_identifier.is_some()
    }

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

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

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

    // optional uint32 time_created = 9;

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

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

    // optional uint32 revocation_attempts_remaining = 10;

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

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

    // optional string classified_agent = 11;

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

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

    pub fn has_classified_agent(&self) -> bool {
        self.classified_agent.is_some()
    }

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

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

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

    // optional bool allow_external_authenticator = 12;

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

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

    // optional uint32 time_transferred = 13;

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

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

    // optional uint32 version = 14;

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

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

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

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

    // optional fixed64 last_seen_auth_token_id = 15;

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

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

    pub fn has_last_seen_auth_token_id(&self) -> bool {
        self.last_seen_auth_token_id.is_some()
    }

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.state = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.inactivation_reason = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.authenticator_type = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.authenticator_allowed = ::std::option::Option::Some(is.read_bool()?);
                },
                40 => {
                    self.steamguard_scheme = ::std::option::Option::Some(is.read_uint32()?);
                },
                50 => {
                    self.token_gid = ::std::option::Option::Some(is.read_string()?);
                },
                56 => {
                    self.email_validated = ::std::option::Option::Some(is.read_bool()?);
                },
                66 => {
                    self.device_identifier = ::std::option::Option::Some(is.read_string()?);
                },
                72 => {
                    self.time_created = ::std::option::Option::Some(is.read_uint32()?);
                },
                80 => {
                    self.revocation_attempts_remaining = ::std::option::Option::Some(is.read_uint32()?);
                },
                90 => {
                    self.classified_agent = ::std::option::Option::Some(is.read_string()?);
                },
                96 => {
                    self.allow_external_authenticator = ::std::option::Option::Some(is.read_bool()?);
                },
                104 => {
                    self.time_transferred = ::std::option::Option::Some(is.read_uint32()?);
                },
                112 => {
                    self.version = ::std::option::Option::Some(is.read_uint32()?);
                },
                121 => {
                    self.last_seen_auth_token_id = ::std::option::Option::Some(is.read_fixed64()?);
                },
                130 => {
                    self.usages.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.state {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.inactivation_reason {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.authenticator_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.authenticator_allowed {
            my_size += 1 + 1;
        }
        if let Some(v) = self.steamguard_scheme {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.token_gid.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.email_validated {
            my_size += 1 + 1;
        }
        if let Some(v) = self.device_identifier.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(8, &v);
        }
        if let Some(v) = self.time_created {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
        }
        if let Some(v) = self.revocation_attempts_remaining {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(10, v);
        }
        if let Some(v) = self.classified_agent.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(11, &v);
        }
        if let Some(v) = self.allow_external_authenticator {
            my_size += 1 + 1;
        }
        if let Some(v) = self.time_transferred {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(13, v);
        }
        if let Some(v) = self.version {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(14, v);
        }
        if let Some(v) = self.last_seen_auth_token_id {
            my_size += 1 + 8;
        }
        for value in &self.usages {
            let len = value.compute_size();
            my_size += 2 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        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(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(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(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)?;
        }
        if let Some(v) = self.version {
            os.write_uint32(14, v)?;
        }
        if let Some(v) = self.last_seen_auth_token_id {
            os.write_fixed64(15, v)?;
        }
        for v in &self.usages {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(16, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    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 = ::std::option::Option::None;
        self.email_validated = ::std::option::Option::None;
        self.device_identifier = ::std::option::Option::None;
        self.time_created = ::std::option::Option::None;
        self.revocation_attempts_remaining = ::std::option::Option::None;
        self.classified_agent = ::std::option::Option::None;
        self.allow_external_authenticator = ::std::option::Option::None;
        self.time_transferred = ::std::option::Option::None;
        self.version = ::std::option::Option::None;
        self.last_seen_auth_token_id = ::std::option::Option::None;
        self.usages.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CTwoFactor_Status_Response {
        static instance: CTwoFactor_Status_Response = CTwoFactor_Status_Response {
            state: ::std::option::Option::None,
            inactivation_reason: ::std::option::Option::None,
            authenticator_type: ::std::option::Option::None,
            authenticator_allowed: ::std::option::Option::None,
            steamguard_scheme: ::std::option::Option::None,
            token_gid: ::std::option::Option::None,
            email_validated: ::std::option::Option::None,
            device_identifier: ::std::option::Option::None,
            time_created: ::std::option::Option::None,
            revocation_attempts_remaining: ::std::option::Option::None,
            classified_agent: ::std::option::Option::None,
            allow_external_authenticator: ::std::option::Option::None,
            time_transferred: ::std::option::Option::None,
            version: ::std::option::Option::None,
            last_seen_auth_token_id: ::std::option::Option::None,
            usages: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CTwoFactor_AddAuthenticator_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CTwoFactor_AddAuthenticator_Request {
    // message fields
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Request.authenticator_time)
    pub authenticator_time: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Request.serial_number)
    pub serial_number: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Request.authenticator_type)
    pub authenticator_type: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Request.device_identifier)
    pub device_identifier: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Request.http_headers)
    pub http_headers: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Request.version)
    pub version: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CTwoFactor_AddAuthenticator_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed64 steamid = 1;

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

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

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

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

    // optional uint64 authenticator_time = 2;

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

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

    // optional fixed64 serial_number = 3;

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

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

    // optional uint32 authenticator_type = 4;

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

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

    // optional string device_identifier = 5;

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

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

    pub fn has_device_identifier(&self) -> bool {
        self.device_identifier.is_some()
    }

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

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

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

    // optional uint32 version = 8;

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

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

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

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                9 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                16 => {
                    self.authenticator_time = ::std::option::Option::Some(is.read_uint64()?);
                },
                25 => {
                    self.serial_number = ::std::option::Option::Some(is.read_fixed64()?);
                },
                32 => {
                    self.authenticator_type = ::std::option::Option::Some(is.read_uint32()?);
                },
                42 => {
                    self.device_identifier = ::std::option::Option::Some(is.read_string()?);
                },
                58 => {
                    self.http_headers.push(is.read_string()?);
                },
                64 => {
                    self.version = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.steamid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.authenticator_time {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.serial_number {
            my_size += 1 + 8;
        }
        if let Some(v) = self.authenticator_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.device_identifier.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &v);
        }
        for value in &self.http_headers {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &value);
        };
        if let Some(v) = self.version {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.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(v) = self.device_identifier.as_ref() {
            os.write_string(5, v)?;
        }
        for v in &self.http_headers {
            os.write_string(7, &v)?;
        };
        if let Some(v) = self.version {
            os.write_uint32(8, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    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 = ::std::option::Option::None;
        self.http_headers.clear();
        self.version = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CTwoFactor_AddAuthenticator_Request {
        static instance: CTwoFactor_AddAuthenticator_Request = CTwoFactor_AddAuthenticator_Request {
            steamid: ::std::option::Option::None,
            authenticator_time: ::std::option::Option::None,
            serial_number: ::std::option::Option::None,
            authenticator_type: ::std::option::Option::None,
            device_identifier: ::std::option::Option::None,
            http_headers: ::std::vec::Vec::new(),
            version: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CTwoFactor_AddAuthenticator_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CTwoFactor_AddAuthenticator_Response {
    // message fields
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Response.shared_secret)
    pub shared_secret: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Response.serial_number)
    pub serial_number: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Response.revocation_code)
    pub revocation_code: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Response.uri)
    pub uri: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Response.server_time)
    pub server_time: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Response.account_name)
    pub account_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Response.token_gid)
    pub token_gid: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Response.identity_secret)
    pub identity_secret: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Response.secret_1)
    pub secret_1: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Response.status)
    pub status: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Response.phone_number_hint)
    pub phone_number_hint: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CTwoFactor_AddAuthenticator_Response.confirm_type)
    pub confirm_type: ::std::option::Option<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:CTwoFactor_AddAuthenticator_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional bytes shared_secret = 1;

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

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

    pub fn has_shared_secret(&self) -> bool {
        self.shared_secret.is_some()
    }

    // Param is passed by value, moved
    pub fn set_shared_secret(&mut self, v: ::std::vec::Vec<u8>) {
        self.shared_secret = ::std::option::Option::Some(v);
    }

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

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

    // optional fixed64 serial_number = 2;

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

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

    // optional string revocation_code = 3;

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

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

    pub fn has_revocation_code(&self) -> bool {
        self.revocation_code.is_some()
    }

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

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

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

    // optional string uri = 4;

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

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

    pub fn has_uri(&self) -> bool {
        self.uri.is_some()
    }

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

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

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

    // optional uint64 server_time = 5;

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

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

    // optional string account_name = 6;

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

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

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

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

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

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

    // optional string token_gid = 7;

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

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

    pub fn has_token_gid(&self) -> bool {
        self.token_gid.is_some()
    }

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

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

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

    // optional bytes identity_secret = 8;

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

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

    pub fn has_identity_secret(&self) -> bool {
        self.identity_secret.is_some()
    }

    // Param is passed by value, moved
    pub fn set_identity_secret(&mut self, v: ::std::vec::Vec<u8>) {
        self.identity_secret = ::std::option::Option::Some(v);
    }

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

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

    // optional bytes secret_1 = 9;

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

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

    pub fn has_secret_1(&self) -> bool {
        self.secret_1.is_some()
    }

    // Param is passed by value, moved
    pub fn set_secret_1(&mut self, v: ::std::vec::Vec<u8>) {
        self.secret_1 = ::std::option::Option::Some(v);
    }

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

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

    // optional int32 status = 10;

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

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

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

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

    // optional string phone_number_hint = 11;

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

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

    pub fn has_phone_number_hint(&self) -> bool {
        self.phone_number_hint.is_some()
    }

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

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

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

    // optional int32 confirm_type = 12;

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

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

    pub fn has_confirm_type(&self) -> bool {
        self.confirm_type.is_some()
    }

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.shared_secret = ::std::option::Option::Some(is.read_bytes()?);
                },
                17 => {
                    self.serial_number = ::std::option::Option::Some(is.read_fixed64()?);
                },
                26 => {
                    self.revocation_code = ::std::option::Option::Some(is.read_string()?);
                },
                34 => {
                    self.uri = ::std::option::Option::Some(is.read_string()?);
                },
                40 => {
                    self.server_time = ::std::option::Option::Some(is.read_uint64()?);
                },
                50 => {
                    self.account_name = ::std::option::Option::Some(is.read_string()?);
                },
                58 => {
                    self.token_gid = ::std::option::Option::Some(is.read_string()?);
                },
                66 => {
                    self.identity_secret = ::std::option::Option::Some(is.read_bytes()?);
                },
                74 => {
                    self.secret_1 = ::std::option::Option::Some(is.read_bytes()?);
                },
                80 => {
                    self.status = ::std::option::Option::Some(is.read_int32()?);
                },
                90 => {
                    self.phone_number_hint = ::std::option::Option::Some(is.read_string()?);
                },
                96 => {
                    self.confirm_type = ::std::option::Option::Some(is.read_int32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.shared_secret.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(v) = self.serial_number {
            my_size += 1 + 8;
        }
        if let Some(v) = self.revocation_code.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.uri.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.server_time {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(5, v);
        }
        if let Some(v) = self.account_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.token_gid.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
        }
        if let Some(v) = self.identity_secret.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(8, &v);
        }
        if let Some(v) = self.secret_1.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(9, &v);
        }
        if let Some(v) = self.status {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(10, v);
        }
        if let Some(v) = self.phone_number_hint.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(11, &v);
        }
        if let Some(v) = self.confirm_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(12, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.shared_secret.as_ref() {
            os.write_bytes(1, v)?;
        }
        if let Some(v) = self.serial_number {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.revocation_code.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(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(v) = self.account_name.as_ref() {
            os.write_string(6, v)?;
        }
        if let Some(v) = self.token_gid.as_ref() {
            os.write_string(7, v)?;
        }
        if let Some(v) = self.identity_secret.as_ref() {
            os.write_bytes(8, v)?;
        }
        if let Some(v) = self.secret_1.as_ref() {
            os.write_bytes(9, v)?;
        }
        if let Some(v) = self.status {
            os.write_int32(10, v)?;
        }
        if let Some(v) = self.phone_number_hint.as_ref() {
            os.write_string(11, v)?;
        }
        if let Some(v) = self.confirm_type {
            os.write_int32(12, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.shared_secret = ::std::option::Option::None;
        self.serial_number = ::std::option::Option::None;
        self.revocation_code = ::std::option::Option::None;
        self.uri = ::std::option::Option::None;
        self.server_time = ::std::option::Option::None;
        self.account_name = ::std::option::Option::None;
        self.token_gid = ::std::option::Option::None;
        self.identity_secret = ::std::option::Option::None;
        self.secret_1 = ::std::option::Option::None;
        self.status = ::std::option::Option::None;
        self.phone_number_hint = ::std::option::Option::None;
        self.confirm_type = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CTwoFactor_AddAuthenticator_Response {
        static instance: CTwoFactor_AddAuthenticator_Response = CTwoFactor_AddAuthenticator_Response {
            shared_secret: ::std::option::Option::None,
            serial_number: ::std::option::Option::None,
            revocation_code: ::std::option::Option::None,
            uri: ::std::option::Option::None,
            server_time: ::std::option::Option::None,
            account_name: ::std::option::Option::None,
            token_gid: ::std::option::Option::None,
            identity_secret: ::std::option::Option::None,
            secret_1: ::std::option::Option::None,
            status: ::std::option::Option::None,
            phone_number_hint: ::std::option::Option::None,
            confirm_type: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CTwoFactor_FinalizeAddAuthenticator_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CTwoFactor_FinalizeAddAuthenticator_Request {
    // message fields
    // @@protoc_insertion_point(field:CTwoFactor_FinalizeAddAuthenticator_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CTwoFactor_FinalizeAddAuthenticator_Request.authenticator_code)
    pub authenticator_code: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CTwoFactor_FinalizeAddAuthenticator_Request.authenticator_time)
    pub authenticator_time: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CTwoFactor_FinalizeAddAuthenticator_Request.activation_code)
    pub activation_code: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CTwoFactor_FinalizeAddAuthenticator_Request.http_headers)
    pub http_headers: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CTwoFactor_FinalizeAddAuthenticator_Request.validate_sms_code)
    pub validate_sms_code: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CTwoFactor_FinalizeAddAuthenticator_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed64 steamid = 1;

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

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

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

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

    // optional string authenticator_code = 2;

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

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

    pub fn has_authenticator_code(&self) -> bool {
        self.authenticator_code.is_some()
    }

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

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

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

    // optional uint64 authenticator_time = 3;

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

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

    // optional string activation_code = 4;

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

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

    pub fn has_activation_code(&self) -> bool {
        self.activation_code.is_some()
    }

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

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

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

    // optional bool validate_sms_code = 6;

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

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

    pub fn has_validate_sms_code(&self) -> bool {
        self.validate_sms_code.is_some()
    }

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                9 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                18 => {
                    self.authenticator_code = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.authenticator_time = ::std::option::Option::Some(is.read_uint64()?);
                },
                34 => {
                    self.activation_code = ::std::option::Option::Some(is.read_string()?);
                },
                42 => {
                    self.http_headers.push(is.read_string()?);
                },
                48 => {
                    self.validate_sms_code = ::std::option::Option::Some(is.read_bool()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.steamid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.authenticator_code.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.authenticator_time {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
        }
        if let Some(v) = self.activation_code.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        for value in &self.http_headers {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &value);
        };
        if let Some(v) = self.validate_sms_code {
            my_size += 1 + 1;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(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(v) = self.activation_code.as_ref() {
            os.write_string(4, v)?;
        }
        for v in &self.http_headers {
            os.write_string(5, &v)?;
        };
        if let Some(v) = self.validate_sms_code {
            os.write_bool(6, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.authenticator_code = ::std::option::Option::None;
        self.authenticator_time = ::std::option::Option::None;
        self.activation_code = ::std::option::Option::None;
        self.http_headers.clear();
        self.validate_sms_code = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CTwoFactor_FinalizeAddAuthenticator_Request {
        static instance: CTwoFactor_FinalizeAddAuthenticator_Request = CTwoFactor_FinalizeAddAuthenticator_Request {
            steamid: ::std::option::Option::None,
            authenticator_code: ::std::option::Option::None,
            authenticator_time: ::std::option::Option::None,
            activation_code: ::std::option::Option::None,
            http_headers: ::std::vec::Vec::new(),
            validate_sms_code: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional bool success = 1;

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

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

    // optional uint64 server_time = 3;

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

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

    // optional int32 status = 4;

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

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

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

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.success = ::std::option::Option::Some(is.read_bool()?);
                },
                24 => {
                    self.server_time = ::std::option::Option::Some(is.read_uint64()?);
                },
                32 => {
                    self.status = ::std::option::Option::Some(is.read_int32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.success {
            os.write_bool(1, 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.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

    // optional fixed64 steamid = 1;

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

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

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

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

    // optional uint32 version = 2;

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

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

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

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

    // optional bytes signature = 3;

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

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

    pub fn has_signature(&self) -> bool {
        self.signature.is_some()
    }

    // Param is passed by value, moved
    pub fn set_signature(&mut self, v: ::std::vec::Vec<u8>) {
        self.signature = ::std::option::Option::Some(v);
    }

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

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                9 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                16 => {
                    self.version = ::std::option::Option::Some(is.read_uint32()?);
                },
                26 => {
                    self.signature = ::std::option::Option::Some(is.read_bytes()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.version {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.signature.as_ref() {
            os.write_bytes(3, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional string revocation_code = 2;

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

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

    pub fn has_revocation_code(&self) -> bool {
        self.revocation_code.is_some()
    }

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

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

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

    // optional uint32 revocation_reason = 5;

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

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

    // optional uint32 steamguard_scheme = 6;

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

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

    // optional bool remove_all_steamguard_cookies = 7;

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

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                18 => {
                    self.revocation_code = ::std::option::Option::Some(is.read_string()?);
                },
                40 => {
                    self.revocation_reason = ::std::option::Option::Some(is.read_uint32()?);
                },
                48 => {
                    self.steamguard_scheme = ::std::option::Option::Some(is.read_uint32()?);
                },
                56 => {
                    self.remove_all_steamguard_cookies = ::std::option::Option::Some(is.read_bool()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.revocation_code.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.revocation_reason {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.steamguard_scheme {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.remove_all_steamguard_cookies {
            my_size += 1 + 1;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.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.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.revocation_code = ::std::option::Option::None;
        self.revocation_reason = ::std::option::Option::None;
        self.steamguard_scheme = ::std::option::Option::None;
        self.remove_all_steamguard_cookies = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CTwoFactor_RemoveAuthenticator_Request {
        static instance: CTwoFactor_RemoveAuthenticator_Request = CTwoFactor_RemoveAuthenticator_Request {
            revocation_code: ::std::option::Option::None,
            revocation_reason: ::std::option::Option::None,
            steamguard_scheme: ::std::option::Option::None,
            remove_all_steamguard_cookies: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional bool success = 1;

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

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

    // optional uint64 server_time = 3;

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

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

    // optional uint32 revocation_attempts_remaining = 5;

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

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.success = ::std::option::Option::Some(is.read_bool()?);
                },
                24 => {
                    self.server_time = ::std::option::Option::Some(is.read_uint64()?);
                },
                40 => {
                    self.revocation_attempts_remaining = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.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.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    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.special_fields.clear();
    }

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

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

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

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional bool success = 1;

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

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.success = ::std::option::Option::Some(is.read_bool()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional string sms_code = 1;

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

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

    pub fn has_sms_code(&self) -> bool {
        self.sms_code.is_some()
    }

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

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

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

    // optional bool generate_new_token = 2;

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

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

    pub fn has_generate_new_token(&self) -> bool {
        self.generate_new_token.is_some()
    }

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

    // optional uint32 version = 3;

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

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

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

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.sms_code = ::std::option::Option::Some(is.read_string()?);
                },
                16 => {
                    self.generate_new_token = ::std::option::Option::Some(is.read_bool()?);
                },
                24 => {
                    self.version = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.sms_code.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.generate_new_token {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.version {
            os.write_uint32(3, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

// @@protoc_insertion_point(message:CRemoveAuthenticatorViaChallengeContinue_Replacement_Token)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CRemoveAuthenticatorViaChallengeContinue_Replacement_Token {
    // message fields
    // @@protoc_insertion_point(field:CRemoveAuthenticatorViaChallengeContinue_Replacement_Token.shared_secret)
    pub shared_secret: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CRemoveAuthenticatorViaChallengeContinue_Replacement_Token.serial_number)
    pub serial_number: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CRemoveAuthenticatorViaChallengeContinue_Replacement_Token.revocation_code)
    pub revocation_code: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CRemoveAuthenticatorViaChallengeContinue_Replacement_Token.uri)
    pub uri: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CRemoveAuthenticatorViaChallengeContinue_Replacement_Token.server_time)
    pub server_time: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CRemoveAuthenticatorViaChallengeContinue_Replacement_Token.account_name)
    pub account_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CRemoveAuthenticatorViaChallengeContinue_Replacement_Token.token_gid)
    pub token_gid: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CRemoveAuthenticatorViaChallengeContinue_Replacement_Token.identity_secret)
    pub identity_secret: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CRemoveAuthenticatorViaChallengeContinue_Replacement_Token.secret_1)
    pub secret_1: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CRemoveAuthenticatorViaChallengeContinue_Replacement_Token.status)
    pub status: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CRemoveAuthenticatorViaChallengeContinue_Replacement_Token.steamguard_scheme)
    pub steamguard_scheme: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CRemoveAuthenticatorViaChallengeContinue_Replacement_Token.steamid)
    pub steamid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CRemoveAuthenticatorViaChallengeContinue_Replacement_Token.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional bytes shared_secret = 1;

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

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

    pub fn has_shared_secret(&self) -> bool {
        self.shared_secret.is_some()
    }

    // Param is passed by value, moved
    pub fn set_shared_secret(&mut self, v: ::std::vec::Vec<u8>) {
        self.shared_secret = ::std::option::Option::Some(v);
    }

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

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

    // optional fixed64 serial_number = 2;

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

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

    // optional string revocation_code = 3;

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

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

    pub fn has_revocation_code(&self) -> bool {
        self.revocation_code.is_some()
    }

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

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

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

    // optional string uri = 4;

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

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

    pub fn has_uri(&self) -> bool {
        self.uri.is_some()
    }

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

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

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

    // optional uint64 server_time = 5;

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

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

    // optional string account_name = 6;

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

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

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

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

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

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

    // optional string token_gid = 7;

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

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

    pub fn has_token_gid(&self) -> bool {
        self.token_gid.is_some()
    }

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

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

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

    // optional bytes identity_secret = 8;

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

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

    pub fn has_identity_secret(&self) -> bool {
        self.identity_secret.is_some()
    }

    // Param is passed by value, moved
    pub fn set_identity_secret(&mut self, v: ::std::vec::Vec<u8>) {
        self.identity_secret = ::std::option::Option::Some(v);
    }

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

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

    // optional bytes secret_1 = 9;

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

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

    pub fn has_secret_1(&self) -> bool {
        self.secret_1.is_some()
    }

    // Param is passed by value, moved
    pub fn set_secret_1(&mut self, v: ::std::vec::Vec<u8>) {
        self.secret_1 = ::std::option::Option::Some(v);
    }

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

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

    // optional int32 status = 10;

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

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

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

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

    // optional uint32 steamguard_scheme = 11;

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

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

    // optional fixed64 steamid = 12;

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

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

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

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.shared_secret = ::std::option::Option::Some(is.read_bytes()?);
                },
                17 => {
                    self.serial_number = ::std::option::Option::Some(is.read_fixed64()?);
                },
                26 => {
                    self.revocation_code = ::std::option::Option::Some(is.read_string()?);
                },
                34 => {
                    self.uri = ::std::option::Option::Some(is.read_string()?);
                },
                40 => {
                    self.server_time = ::std::option::Option::Some(is.read_uint64()?);
                },
                50 => {
                    self.account_name = ::std::option::Option::Some(is.read_string()?);
                },
                58 => {
                    self.token_gid = ::std::option::Option::Some(is.read_string()?);
                },
                66 => {
                    self.identity_secret = ::std::option::Option::Some(is.read_bytes()?);
                },
                74 => {
                    self.secret_1 = ::std::option::Option::Some(is.read_bytes()?);
                },
                80 => {
                    self.status = ::std::option::Option::Some(is.read_int32()?);
                },
                88 => {
                    self.steamguard_scheme = ::std::option::Option::Some(is.read_uint32()?);
                },
                97 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.shared_secret.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(v) = self.serial_number {
            my_size += 1 + 8;
        }
        if let Some(v) = self.revocation_code.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.uri.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.server_time {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(5, v);
        }
        if let Some(v) = self.account_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.token_gid.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
        }
        if let Some(v) = self.identity_secret.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(8, &v);
        }
        if let Some(v) = self.secret_1.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(9, &v);
        }
        if let Some(v) = self.status {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(10, v);
        }
        if let Some(v) = self.steamguard_scheme {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(11, v);
        }
        if let Some(v) = self.steamid {
            my_size += 1 + 8;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.shared_secret.as_ref() {
            os.write_bytes(1, v)?;
        }
        if let Some(v) = self.serial_number {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.revocation_code.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(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(v) = self.account_name.as_ref() {
            os.write_string(6, v)?;
        }
        if let Some(v) = self.token_gid.as_ref() {
            os.write_string(7, v)?;
        }
        if let Some(v) = self.identity_secret.as_ref() {
            os.write_bytes(8, v)?;
        }
        if let Some(v) = self.secret_1.as_ref() {
            os.write_bytes(9, v)?;
        }
        if let Some(v) = self.status {
            os.write_int32(10, v)?;
        }
        if let Some(v) = self.steamguard_scheme {
            os.write_uint32(11, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_fixed64(12, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.shared_secret = ::std::option::Option::None;
        self.serial_number = ::std::option::Option::None;
        self.revocation_code = ::std::option::Option::None;
        self.uri = ::std::option::Option::None;
        self.server_time = ::std::option::Option::None;
        self.account_name = ::std::option::Option::None;
        self.token_gid = ::std::option::Option::None;
        self.identity_secret = ::std::option::Option::None;
        self.secret_1 = ::std::option::Option::None;
        self.status = ::std::option::Option::None;
        self.steamguard_scheme = ::std::option::Option::None;
        self.steamid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CRemoveAuthenticatorViaChallengeContinue_Replacement_Token {
        static instance: CRemoveAuthenticatorViaChallengeContinue_Replacement_Token = CRemoveAuthenticatorViaChallengeContinue_Replacement_Token {
            shared_secret: ::std::option::Option::None,
            serial_number: ::std::option::Option::None,
            revocation_code: ::std::option::Option::None,
            uri: ::std::option::Option::None,
            server_time: ::std::option::Option::None,
            account_name: ::std::option::Option::None,
            token_gid: ::std::option::Option::None,
            identity_secret: ::std::option::Option::None,
            secret_1: ::std::option::Option::None,
            status: ::std::option::Option::None,
            steamguard_scheme: ::std::option::Option::None,
            steamid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional bool success = 1;

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

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

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

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.success = ::std::option::Option::Some(is.read_bool()?);
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.replacement_token)?;
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.success {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.replacement_token.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

    fn default_instance() -> &'static CTwoFactor_RemoveAuthenticatorViaChallengeContinue_Response {
        static instance: CTwoFactor_RemoveAuthenticatorViaChallengeContinue_Response = CTwoFactor_RemoveAuthenticatorViaChallengeContinue_Response {
            success: ::std::option::Option::None,
            replacement_token: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:ETwoFactorStatusFieldFlag)
pub enum ETwoFactorStatusFieldFlag {
    // @@protoc_insertion_point(enum_value:ETwoFactorStatusFieldFlag.k_ETwoFactorStatusFieldFlag_None)
    k_ETwoFactorStatusFieldFlag_None = 0,
    // @@protoc_insertion_point(enum_value:ETwoFactorStatusFieldFlag.k_ETwoFactorStatusFieldFlag_LastUsage)
    k_ETwoFactorStatusFieldFlag_LastUsage = 1,
}

impl ::steam_vent_proto_common::protobuf::Enum for ETwoFactorStatusFieldFlag {
    const NAME: &'static str = "ETwoFactorStatusFieldFlag";

    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<ETwoFactorStatusFieldFlag> {
        match value {
            0 => ::std::option::Option::Some(ETwoFactorStatusFieldFlag::k_ETwoFactorStatusFieldFlag_None),
            1 => ::std::option::Option::Some(ETwoFactorStatusFieldFlag::k_ETwoFactorStatusFieldFlag_LastUsage),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<ETwoFactorStatusFieldFlag> {
        match str {
            "k_ETwoFactorStatusFieldFlag_None" => ::std::option::Option::Some(ETwoFactorStatusFieldFlag::k_ETwoFactorStatusFieldFlag_None),
            "k_ETwoFactorStatusFieldFlag_LastUsage" => ::std::option::Option::Some(ETwoFactorStatusFieldFlag::k_ETwoFactorStatusFieldFlag_LastUsage),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [ETwoFactorStatusFieldFlag] = &[
        ETwoFactorStatusFieldFlag::k_ETwoFactorStatusFieldFlag_None,
        ETwoFactorStatusFieldFlag::k_ETwoFactorStatusFieldFlag_LastUsage,
    ];
}

impl ::std::default::Default for ETwoFactorStatusFieldFlag {
    fn default() -> Self {
        ETwoFactorStatusFieldFlag::k_ETwoFactorStatusFieldFlag_None
    }
}


#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:ETwoFactorUsageType)
pub enum ETwoFactorUsageType {
    // @@protoc_insertion_point(enum_value:ETwoFactorUsageType.k_ETwoFactorUsageType_Unknown)
    k_ETwoFactorUsageType_Unknown = 0,
    // @@protoc_insertion_point(enum_value:ETwoFactorUsageType.k_ETwoFactorUsageType_None)
    k_ETwoFactorUsageType_None = 1,
    // @@protoc_insertion_point(enum_value:ETwoFactorUsageType.k_ETwoFactorUsageType_MobileConfirmation)
    k_ETwoFactorUsageType_MobileConfirmation = 2,
    // @@protoc_insertion_point(enum_value:ETwoFactorUsageType.k_ETwoFactorUsageType_Login)
    k_ETwoFactorUsageType_Login = 3,
}

impl ::steam_vent_proto_common::protobuf::Enum for ETwoFactorUsageType {
    const NAME: &'static str = "ETwoFactorUsageType";

    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<ETwoFactorUsageType> {
        match value {
            0 => ::std::option::Option::Some(ETwoFactorUsageType::k_ETwoFactorUsageType_Unknown),
            1 => ::std::option::Option::Some(ETwoFactorUsageType::k_ETwoFactorUsageType_None),
            2 => ::std::option::Option::Some(ETwoFactorUsageType::k_ETwoFactorUsageType_MobileConfirmation),
            3 => ::std::option::Option::Some(ETwoFactorUsageType::k_ETwoFactorUsageType_Login),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<ETwoFactorUsageType> {
        match str {
            "k_ETwoFactorUsageType_Unknown" => ::std::option::Option::Some(ETwoFactorUsageType::k_ETwoFactorUsageType_Unknown),
            "k_ETwoFactorUsageType_None" => ::std::option::Option::Some(ETwoFactorUsageType::k_ETwoFactorUsageType_None),
            "k_ETwoFactorUsageType_MobileConfirmation" => ::std::option::Option::Some(ETwoFactorUsageType::k_ETwoFactorUsageType_MobileConfirmation),
            "k_ETwoFactorUsageType_Login" => ::std::option::Option::Some(ETwoFactorUsageType::k_ETwoFactorUsageType_Login),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [ETwoFactorUsageType] = &[
        ETwoFactorUsageType::k_ETwoFactorUsageType_Unknown,
        ETwoFactorUsageType::k_ETwoFactorUsageType_None,
        ETwoFactorUsageType::k_ETwoFactorUsageType_MobileConfirmation,
        ETwoFactorUsageType::k_ETwoFactorUsageType_Login,
    ];
}

impl ::std::default::Default for ETwoFactorUsageType {
    fn default() -> Self {
        ETwoFactorUsageType::k_ETwoFactorUsageType_Unknown
    }
}



const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;

#[allow(unused_imports)]
use crate::steammessages_base::*;
#[allow(unused_imports)]
use crate::steammessages_unified_base_steamclient::*;
impl ::steam_vent_proto_common::RpcMessage for CTwoFactor_Time_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CTwoFactor_Time_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CTwoFactor_Status_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CTwoFactor_UsageEvent {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CTwoFactor_Status_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CTwoFactor_AddAuthenticator_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CTwoFactor_AddAuthenticator_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CTwoFactor_FinalizeAddAuthenticator_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CTwoFactor_FinalizeAddAuthenticator_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CTwoFactor_UpdateTokenVersion_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CTwoFactor_UpdateTokenVersion_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CTwoFactor_RemoveAuthenticator_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CTwoFactor_RemoveAuthenticator_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CTwoFactor_RemoveAuthenticatorViaChallengeStart_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CTwoFactor_RemoveAuthenticatorViaChallengeStart_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CTwoFactor_RemoveAuthenticatorViaChallengeContinue_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CRemoveAuthenticatorViaChallengeContinue_Replacement_Token {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CTwoFactor_RemoveAuthenticatorViaChallengeContinue_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
///
struct TwoFactor {}
impl ::steam_vent_proto_common::RpcService for TwoFactor {
    const SERVICE_NAME: &'static str = "TwoFactor";
}
impl ::steam_vent_proto_common::RpcMethod for CTwoFactor_AddAuthenticator_Request {
    const METHOD_NAME: &'static str = "TwoFactor.AddAuthenticator#1";
    type Response = CTwoFactor_AddAuthenticator_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CTwoFactor_FinalizeAddAuthenticator_Request {
    const METHOD_NAME: &'static str = "TwoFactor.FinalizeAddAuthenticator#1";
    type Response = CTwoFactor_FinalizeAddAuthenticator_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CTwoFactor_RemoveAuthenticatorViaChallengeContinue_Request {
    const METHOD_NAME: &'static str = "TwoFactor.RemoveAuthenticatorViaChallengeContinue#1";
    type Response = CTwoFactor_RemoveAuthenticatorViaChallengeContinue_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CTwoFactor_RemoveAuthenticatorViaChallengeStart_Request {
    const METHOD_NAME: &'static str = "TwoFactor.RemoveAuthenticatorViaChallengeStart#1";
    type Response = CTwoFactor_RemoveAuthenticatorViaChallengeStart_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CTwoFactor_RemoveAuthenticator_Request {
    const METHOD_NAME: &'static str = "TwoFactor.RemoveAuthenticator#1";
    type Response = CTwoFactor_RemoveAuthenticator_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CTwoFactor_Status_Request {
    const METHOD_NAME: &'static str = "TwoFactor.QueryStatus#1";
    type Response = CTwoFactor_Status_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CTwoFactor_Time_Request {
    const METHOD_NAME: &'static str = "TwoFactor.QueryTime#1";
    type Response = CTwoFactor_Time_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CTwoFactor_UpdateTokenVersion_Request {
    const METHOD_NAME: &'static str = "TwoFactor.UpdateTokenVersion#1";
    type Response = CTwoFactor_UpdateTokenVersion_Response;
}
