steam-vent-proto 0.1.0

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

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

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

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

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

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

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

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

    // optional string country_code = 1;


    pub fn get_country_code(&self) -> &str {
        match self.country_code.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_country_code(&mut self) {
        self.country_code.clear();
    }

    pub fn has_country_code(&self) -> bool {
        self.country_code.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CUserAccount_GetAvailableValveDiscountPromotions_Response {
    // message fields
    pub promotions: ::protobuf::RepeatedField<CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .CUserAccount_GetAvailableValveDiscountPromotions_Response.ValveDiscountPromotionDetails promotions = 1;


    pub fn get_promotions(&self) -> &[CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails] {
        &self.promotions
    }
    pub fn clear_promotions(&mut self) {
        self.promotions.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_promotions(&mut self) -> &mut ::protobuf::RepeatedField<CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails> {
        &mut self.promotions
    }

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.promotions {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails {
    // message fields
    promotionid: ::std::option::Option<u32>,
    promotion_description: ::protobuf::SingularField<::std::string::String>,
    minimum_cart_amount: ::std::option::Option<i64>,
    minimum_cart_amount_for_display: ::std::option::Option<i64>,
    discount_amount: ::std::option::Option<i64>,
    currency_code: ::std::option::Option<i32>,
    available_use_count: ::std::option::Option<i32>,
    promotional_discount_type: ::std::option::Option<i32>,
    loyalty_reward_id: ::std::option::Option<i32>,
    localized_name_token: ::protobuf::SingularField<::std::string::String>,
    max_use_count: ::std::option::Option<i32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 promotionid = 1;


    pub fn get_promotionid(&self) -> u32 {
        self.promotionid.unwrap_or(0)
    }
    pub fn clear_promotionid(&mut self) {
        self.promotionid = ::std::option::Option::None;
    }

    pub fn has_promotionid(&self) -> bool {
        self.promotionid.is_some()
    }

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

    // optional string promotion_description = 2;


    pub fn get_promotion_description(&self) -> &str {
        match self.promotion_description.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_promotion_description(&mut self) {
        self.promotion_description.clear();
    }

    pub fn has_promotion_description(&self) -> bool {
        self.promotion_description.is_some()
    }

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

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

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

    // optional int64 minimum_cart_amount = 3;


    pub fn get_minimum_cart_amount(&self) -> i64 {
        self.minimum_cart_amount.unwrap_or(0)
    }
    pub fn clear_minimum_cart_amount(&mut self) {
        self.minimum_cart_amount = ::std::option::Option::None;
    }

    pub fn has_minimum_cart_amount(&self) -> bool {
        self.minimum_cart_amount.is_some()
    }

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

    // optional int64 minimum_cart_amount_for_display = 4;


    pub fn get_minimum_cart_amount_for_display(&self) -> i64 {
        self.minimum_cart_amount_for_display.unwrap_or(0)
    }
    pub fn clear_minimum_cart_amount_for_display(&mut self) {
        self.minimum_cart_amount_for_display = ::std::option::Option::None;
    }

    pub fn has_minimum_cart_amount_for_display(&self) -> bool {
        self.minimum_cart_amount_for_display.is_some()
    }

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

    // optional int64 discount_amount = 5;


    pub fn get_discount_amount(&self) -> i64 {
        self.discount_amount.unwrap_or(0)
    }
    pub fn clear_discount_amount(&mut self) {
        self.discount_amount = ::std::option::Option::None;
    }

    pub fn has_discount_amount(&self) -> bool {
        self.discount_amount.is_some()
    }

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

    // optional int32 currency_code = 6;


    pub fn get_currency_code(&self) -> i32 {
        self.currency_code.unwrap_or(0)
    }
    pub fn clear_currency_code(&mut self) {
        self.currency_code = ::std::option::Option::None;
    }

    pub fn has_currency_code(&self) -> bool {
        self.currency_code.is_some()
    }

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

    // optional int32 available_use_count = 7;


    pub fn get_available_use_count(&self) -> i32 {
        self.available_use_count.unwrap_or(0)
    }
    pub fn clear_available_use_count(&mut self) {
        self.available_use_count = ::std::option::Option::None;
    }

    pub fn has_available_use_count(&self) -> bool {
        self.available_use_count.is_some()
    }

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

    // optional int32 promotional_discount_type = 8;


    pub fn get_promotional_discount_type(&self) -> i32 {
        self.promotional_discount_type.unwrap_or(0)
    }
    pub fn clear_promotional_discount_type(&mut self) {
        self.promotional_discount_type = ::std::option::Option::None;
    }

    pub fn has_promotional_discount_type(&self) -> bool {
        self.promotional_discount_type.is_some()
    }

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

    // optional int32 loyalty_reward_id = 9;


    pub fn get_loyalty_reward_id(&self) -> i32 {
        self.loyalty_reward_id.unwrap_or(0)
    }
    pub fn clear_loyalty_reward_id(&mut self) {
        self.loyalty_reward_id = ::std::option::Option::None;
    }

    pub fn has_loyalty_reward_id(&self) -> bool {
        self.loyalty_reward_id.is_some()
    }

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

    // optional string localized_name_token = 10;


    pub fn get_localized_name_token(&self) -> &str {
        match self.localized_name_token.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_localized_name_token(&mut self) {
        self.localized_name_token.clear();
    }

    pub fn has_localized_name_token(&self) -> bool {
        self.localized_name_token.is_some()
    }

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

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

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

    // optional int32 max_use_count = 11;


    pub fn get_max_use_count(&self) -> i32 {
        self.max_use_count.unwrap_or(0)
    }
    pub fn clear_max_use_count(&mut self) {
        self.max_use_count = ::std::option::Option::None;
    }

    pub fn has_max_use_count(&self) -> bool {
        self.max_use_count.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.promotionid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.promotion_description)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.minimum_cart_amount = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.minimum_cart_amount_for_display = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.discount_amount = ::std::option::Option::Some(tmp);
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.currency_code = ::std::option::Option::Some(tmp);
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.available_use_count = ::std::option::Option::Some(tmp);
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.promotional_discount_type = ::std::option::Option::Some(tmp);
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.loyalty_reward_id = ::std::option::Option::Some(tmp);
                },
                10 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.localized_name_token)?;
                },
                11 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.max_use_count = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.promotionid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.promotion_description.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.minimum_cart_amount {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.minimum_cart_amount_for_display {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.discount_amount {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.currency_code {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.available_use_count {
            my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.promotional_discount_type {
            my_size += ::protobuf::rt::value_size(8, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.loyalty_reward_id {
            my_size += ::protobuf::rt::value_size(9, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.localized_name_token.as_ref() {
            my_size += ::protobuf::rt::string_size(10, &v);
        }
        if let Some(v) = self.max_use_count {
            my_size += ::protobuf::rt::value_size(11, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.promotionid {
            os.write_uint32(1, v)?;
        }
        if let Some(ref v) = self.promotion_description.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.minimum_cart_amount {
            os.write_int64(3, v)?;
        }
        if let Some(v) = self.minimum_cart_amount_for_display {
            os.write_int64(4, v)?;
        }
        if let Some(v) = self.discount_amount {
            os.write_int64(5, v)?;
        }
        if let Some(v) = self.currency_code {
            os.write_int32(6, v)?;
        }
        if let Some(v) = self.available_use_count {
            os.write_int32(7, v)?;
        }
        if let Some(v) = self.promotional_discount_type {
            os.write_int32(8, v)?;
        }
        if let Some(v) = self.loyalty_reward_id {
            os.write_int32(9, v)?;
        }
        if let Some(ref v) = self.localized_name_token.as_ref() {
            os.write_string(10, &v)?;
        }
        if let Some(v) = self.max_use_count {
            os.write_int32(11, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "promotionid",
                |m: &CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &m.promotionid },
                |m: &mut CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &mut m.promotionid },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "promotion_description",
                |m: &CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &m.promotion_description },
                |m: &mut CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &mut m.promotion_description },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "minimum_cart_amount",
                |m: &CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &m.minimum_cart_amount },
                |m: &mut CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &mut m.minimum_cart_amount },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "minimum_cart_amount_for_display",
                |m: &CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &m.minimum_cart_amount_for_display },
                |m: &mut CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &mut m.minimum_cart_amount_for_display },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "discount_amount",
                |m: &CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &m.discount_amount },
                |m: &mut CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &mut m.discount_amount },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "currency_code",
                |m: &CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &m.currency_code },
                |m: &mut CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &mut m.currency_code },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "available_use_count",
                |m: &CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &m.available_use_count },
                |m: &mut CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &mut m.available_use_count },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "promotional_discount_type",
                |m: &CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &m.promotional_discount_type },
                |m: &mut CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &mut m.promotional_discount_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "loyalty_reward_id",
                |m: &CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &m.loyalty_reward_id },
                |m: &mut CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &mut m.loyalty_reward_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "localized_name_token",
                |m: &CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &m.localized_name_token },
                |m: &mut CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &mut m.localized_name_token },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "max_use_count",
                |m: &CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &m.max_use_count },
                |m: &mut CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails| { &mut m.max_use_count },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails>(
                "CUserAccount_GetAvailableValveDiscountPromotions_Response.ValveDiscountPromotionDetails",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CUserAccount_GetAvailableValveDiscountPromotions_Response_ValveDiscountPromotionDetails {
    fn clear(&mut self) {
        self.promotionid = ::std::option::Option::None;
        self.promotion_description.clear();
        self.minimum_cart_amount = ::std::option::Option::None;
        self.minimum_cart_amount_for_display = ::std::option::Option::None;
        self.discount_amount = ::std::option::Option::None;
        self.currency_code = ::std::option::Option::None;
        self.available_use_count = ::std::option::Option::None;
        self.promotional_discount_type = ::std::option::Option::None;
        self.loyalty_reward_id = ::std::option::Option::None;
        self.localized_name_token.clear();
        self.max_use_count = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional uint32 pwid = 1;


    pub fn get_pwid(&self) -> u32 {
        self.pwid.unwrap_or(0)
    }
    pub fn clear_pwid(&mut self) {
        self.pwid = ::std::option::Option::None;
    }

    pub fn has_pwid(&self) -> bool {
        self.pwid.is_some()
    }

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

    // optional uint32 identity_verification = 2;


    pub fn get_identity_verification(&self) -> u32 {
        self.identity_verification.unwrap_or(0)
    }
    pub fn clear_identity_verification(&mut self) {
        self.identity_verification = ::std::option::Option::None;
    }

    pub fn has_identity_verification(&self) -> bool {
        self.identity_verification.is_some()
    }

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

    // optional bool performed_age_verification = 3;


    pub fn get_performed_age_verification(&self) -> bool {
        self.performed_age_verification.unwrap_or(false)
    }
    pub fn clear_performed_age_verification(&mut self) {
        self.performed_age_verification = ::std::option::Option::None;
    }

    pub fn has_performed_age_verification(&self) -> bool {
        self.performed_age_verification.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

impl ::protobuf::Clear for CUserAccount_GetAccountLinkStatus_Response {
    fn clear(&mut self) {
        self.pwid = ::std::option::Option::None;
        self.identity_verification = ::std::option::Option::None;
        self.performed_age_verification = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional uint32 appid = 1;


    pub fn get_appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }
    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CUserAccount_CreateFriendInviteToken_Request {
    // message fields
    invite_limit: ::std::option::Option<u32>,
    invite_duration: ::std::option::Option<u32>,
    invite_note: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 invite_limit = 1;


    pub fn get_invite_limit(&self) -> u32 {
        self.invite_limit.unwrap_or(0)
    }
    pub fn clear_invite_limit(&mut self) {
        self.invite_limit = ::std::option::Option::None;
    }

    pub fn has_invite_limit(&self) -> bool {
        self.invite_limit.is_some()
    }

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

    // optional uint32 invite_duration = 2;


    pub fn get_invite_duration(&self) -> u32 {
        self.invite_duration.unwrap_or(0)
    }
    pub fn clear_invite_duration(&mut self) {
        self.invite_duration = ::std::option::Option::None;
    }

    pub fn has_invite_duration(&self) -> bool {
        self.invite_duration.is_some()
    }

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

    // optional string invite_note = 3;


    pub fn get_invite_note(&self) -> &str {
        match self.invite_note.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_invite_note(&mut self) {
        self.invite_note.clear();
    }

    pub fn has_invite_note(&self) -> bool {
        self.invite_note.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl ::protobuf::Clear for CUserAccount_CreateFriendInviteToken_Request {
    fn clear(&mut self) {
        self.invite_limit = ::std::option::Option::None;
        self.invite_duration = ::std::option::Option::None;
        self.invite_note.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CUserAccount_CreateFriendInviteToken_Response {
    // message fields
    invite_token: ::protobuf::SingularField<::std::string::String>,
    invite_limit: ::std::option::Option<u64>,
    invite_duration: ::std::option::Option<u64>,
    time_created: ::std::option::Option<u32>,
    valid: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string invite_token = 1;


    pub fn get_invite_token(&self) -> &str {
        match self.invite_token.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_invite_token(&mut self) {
        self.invite_token.clear();
    }

    pub fn has_invite_token(&self) -> bool {
        self.invite_token.is_some()
    }

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

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

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

    // optional uint64 invite_limit = 2;


    pub fn get_invite_limit(&self) -> u64 {
        self.invite_limit.unwrap_or(0)
    }
    pub fn clear_invite_limit(&mut self) {
        self.invite_limit = ::std::option::Option::None;
    }

    pub fn has_invite_limit(&self) -> bool {
        self.invite_limit.is_some()
    }

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

    // optional uint64 invite_duration = 3;


    pub fn get_invite_duration(&self) -> u64 {
        self.invite_duration.unwrap_or(0)
    }
    pub fn clear_invite_duration(&mut self) {
        self.invite_duration = ::std::option::Option::None;
    }

    pub fn has_invite_duration(&self) -> bool {
        self.invite_duration.is_some()
    }

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

    // optional fixed32 time_created = 4;


    pub fn get_time_created(&self) -> u32 {
        self.time_created.unwrap_or(0)
    }
    pub fn clear_time_created(&mut self) {
        self.time_created = ::std::option::Option::None;
    }

    pub fn has_time_created(&self) -> bool {
        self.time_created.is_some()
    }

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

    // optional bool valid = 5;


    pub fn get_valid(&self) -> bool {
        self.valid.unwrap_or(false)
    }
    pub fn clear_valid(&mut self) {
        self.valid = ::std::option::Option::None;
    }

    pub fn has_valid(&self) -> bool {
        self.valid.is_some()
    }

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.invite_token.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(v) = self.invite_limit {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.invite_duration {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.time_created {
            os.write_fixed32(4, v)?;
        }
        if let Some(v) = self.valid {
            os.write_bool(5, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "invite_token",
                |m: &CUserAccount_CreateFriendInviteToken_Response| { &m.invite_token },
                |m: &mut CUserAccount_CreateFriendInviteToken_Response| { &mut m.invite_token },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "invite_limit",
                |m: &CUserAccount_CreateFriendInviteToken_Response| { &m.invite_limit },
                |m: &mut CUserAccount_CreateFriendInviteToken_Response| { &mut m.invite_limit },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "invite_duration",
                |m: &CUserAccount_CreateFriendInviteToken_Response| { &m.invite_duration },
                |m: &mut CUserAccount_CreateFriendInviteToken_Response| { &mut m.invite_duration },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "time_created",
                |m: &CUserAccount_CreateFriendInviteToken_Response| { &m.time_created },
                |m: &mut CUserAccount_CreateFriendInviteToken_Response| { &mut m.time_created },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "valid",
                |m: &CUserAccount_CreateFriendInviteToken_Response| { &m.valid },
                |m: &mut CUserAccount_CreateFriendInviteToken_Response| { &mut m.valid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CUserAccount_CreateFriendInviteToken_Response>(
                "CUserAccount_CreateFriendInviteToken_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CUserAccount_CreateFriendInviteToken_Response {
    fn clear(&mut self) {
        self.invite_token.clear();
        self.invite_limit = ::std::option::Option::None;
        self.invite_duration = ::std::option::Option::None;
        self.time_created = ::std::option::Option::None;
        self.valid = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CUserAccount_GetFriendInviteTokens_Response {
    // message fields
    pub tokens: ::protobuf::RepeatedField<CUserAccount_CreateFriendInviteToken_Response>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .CUserAccount_CreateFriendInviteToken_Response tokens = 1;


    pub fn get_tokens(&self) -> &[CUserAccount_CreateFriendInviteToken_Response] {
        &self.tokens
    }
    pub fn clear_tokens(&mut self) {
        self.tokens.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_tokens(&mut self) -> &mut ::protobuf::RepeatedField<CUserAccount_CreateFriendInviteToken_Response> {
        &mut self.tokens
    }

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.tokens {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CUserAccount_ViewFriendInviteToken_Request {
    // message fields
    steamid: ::std::option::Option<u64>,
    invite_token: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

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

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

    // optional string invite_token = 2;


    pub fn get_invite_token(&self) -> &str {
        match self.invite_token.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_invite_token(&mut self) {
        self.invite_token.clear();
    }

    pub fn has_invite_token(&self) -> bool {
        self.invite_token.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional bool valid = 1;


    pub fn get_valid(&self) -> bool {
        self.valid.unwrap_or(false)
    }
    pub fn clear_valid(&mut self) {
        self.valid = ::std::option::Option::None;
    }

    pub fn has_valid(&self) -> bool {
        self.valid.is_some()
    }

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

    // optional uint64 steamid = 2;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

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

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

    // optional uint64 invite_duration = 3;


    pub fn get_invite_duration(&self) -> u64 {
        self.invite_duration.unwrap_or(0)
    }
    pub fn clear_invite_duration(&mut self) {
        self.invite_duration = ::std::option::Option::None;
    }

    pub fn has_invite_duration(&self) -> bool {
        self.invite_duration.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

impl ::protobuf::Clear for CUserAccount_ViewFriendInviteToken_Response {
    fn clear(&mut self) {
        self.valid = ::std::option::Option::None;
        self.steamid = ::std::option::Option::None;
        self.invite_duration = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CUserAccount_RedeemFriendInviteToken_Request {
    // message fields
    steamid: ::std::option::Option<u64>,
    invite_token: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

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

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

    // optional string invite_token = 2;


    pub fn get_invite_token(&self) -> &str {
        match self.invite_token.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_invite_token(&mut self) {
        self.invite_token.clear();
    }

    pub fn has_invite_token(&self) -> bool {
        self.invite_token.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional string invite_token = 1;


    pub fn get_invite_token(&self) -> &str {
        match self.invite_token.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_invite_token(&mut self) {
        self.invite_token.clear();
    }

    pub fn has_invite_token(&self) -> bool {
        self.invite_token.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional uint32 compat_tool = 1;


    pub fn get_compat_tool(&self) -> u32 {
        self.compat_tool.unwrap_or(0)
    }
    pub fn clear_compat_tool(&mut self) {
        self.compat_tool = ::std::option::Option::None;
    }

    pub fn has_compat_tool(&self) -> bool {
        self.compat_tool.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountLinking_GetLinkedAccountInfo_Request {
    // message fields
    account_type: ::std::option::Option<EInternalAccountType>,
    account_id: ::std::option::Option<u64>,
    filter: ::std::option::Option<EExternalAccountType>,
    return_access_token: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional .EInternalAccountType account_type = 1;


    pub fn get_account_type(&self) -> EInternalAccountType {
        self.account_type.unwrap_or(EInternalAccountType::k_EInternalSteamAccountType)
    }
    pub fn clear_account_type(&mut self) {
        self.account_type = ::std::option::Option::None;
    }

    pub fn has_account_type(&self) -> bool {
        self.account_type.is_some()
    }

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

    // optional uint64 account_id = 2;


    pub fn get_account_id(&self) -> u64 {
        self.account_id.unwrap_or(0)
    }
    pub fn clear_account_id(&mut self) {
        self.account_id = ::std::option::Option::None;
    }

    pub fn has_account_id(&self) -> bool {
        self.account_id.is_some()
    }

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

    // optional .EExternalAccountType filter = 3;


    pub fn get_filter(&self) -> EExternalAccountType {
        self.filter.unwrap_or(EExternalAccountType::k_EExternalNone)
    }
    pub fn clear_filter(&mut self) {
        self.filter = ::std::option::Option::None;
    }

    pub fn has_filter(&self) -> bool {
        self.filter.is_some()
    }

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

    // optional bool return_access_token = 4;


    pub fn get_return_access_token(&self) -> bool {
        self.return_access_token.unwrap_or(false)
    }
    pub fn clear_return_access_token(&mut self) {
        self.return_access_token = ::std::option::Option::None;
    }

    pub fn has_return_access_token(&self) -> bool {
        self.return_access_token.is_some()
    }

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.account_type {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&v))?;
        }
        if let Some(v) = self.account_id {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.filter {
            os.write_enum(3, ::protobuf::ProtobufEnum::value(&v))?;
        }
        if let Some(v) = self.return_access_token {
            os.write_bool(4, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EInternalAccountType>>(
                "account_type",
                |m: &CAccountLinking_GetLinkedAccountInfo_Request| { &m.account_type },
                |m: &mut CAccountLinking_GetLinkedAccountInfo_Request| { &mut m.account_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "account_id",
                |m: &CAccountLinking_GetLinkedAccountInfo_Request| { &m.account_id },
                |m: &mut CAccountLinking_GetLinkedAccountInfo_Request| { &mut m.account_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EExternalAccountType>>(
                "filter",
                |m: &CAccountLinking_GetLinkedAccountInfo_Request| { &m.filter },
                |m: &mut CAccountLinking_GetLinkedAccountInfo_Request| { &mut m.filter },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "return_access_token",
                |m: &CAccountLinking_GetLinkedAccountInfo_Request| { &m.return_access_token },
                |m: &mut CAccountLinking_GetLinkedAccountInfo_Request| { &mut m.return_access_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountLinking_GetLinkedAccountInfo_Request>(
                "CAccountLinking_GetLinkedAccountInfo_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CAccountLinking_GetLinkedAccountInfo_Request {
    fn clear(&mut self) {
        self.account_type = ::std::option::Option::None;
        self.account_id = ::std::option::Option::None;
        self.filter = ::std::option::Option::None;
        self.return_access_token = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountLinking_GetLinkedAccountInfo_Response {
    // message fields
    pub external_accounts: ::protobuf::RepeatedField<CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .CAccountLinking_GetLinkedAccountInfo_Response.CExternalAccountTuple_Response external_accounts = 1;


    pub fn get_external_accounts(&self) -> &[CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response] {
        &self.external_accounts
    }
    pub fn clear_external_accounts(&mut self) {
        self.external_accounts.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_external_accounts(&mut self) -> &mut ::protobuf::RepeatedField<CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response> {
        &mut self.external_accounts
    }

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.external_accounts {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response {
    // message fields
    external_type: ::std::option::Option<EExternalAccountType>,
    external_id: ::protobuf::SingularField<::std::string::String>,
    external_user_name: ::protobuf::SingularField<::std::string::String>,
    external_url: ::protobuf::SingularField<::std::string::String>,
    access_token: ::protobuf::SingularField<::std::string::String>,
    access_token_secret: ::protobuf::SingularField<::std::string::String>,
    is_valid: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional .EExternalAccountType external_type = 1;


    pub fn get_external_type(&self) -> EExternalAccountType {
        self.external_type.unwrap_or(EExternalAccountType::k_EExternalNone)
    }
    pub fn clear_external_type(&mut self) {
        self.external_type = ::std::option::Option::None;
    }

    pub fn has_external_type(&self) -> bool {
        self.external_type.is_some()
    }

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

    // optional string external_id = 2;


    pub fn get_external_id(&self) -> &str {
        match self.external_id.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_external_id(&mut self) {
        self.external_id.clear();
    }

    pub fn has_external_id(&self) -> bool {
        self.external_id.is_some()
    }

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

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

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

    // optional string external_user_name = 3;


    pub fn get_external_user_name(&self) -> &str {
        match self.external_user_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_external_user_name(&mut self) {
        self.external_user_name.clear();
    }

    pub fn has_external_user_name(&self) -> bool {
        self.external_user_name.is_some()
    }

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

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

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

    // optional string external_url = 4;


    pub fn get_external_url(&self) -> &str {
        match self.external_url.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_external_url(&mut self) {
        self.external_url.clear();
    }

    pub fn has_external_url(&self) -> bool {
        self.external_url.is_some()
    }

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

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

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

    // optional string access_token = 5;


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

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

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

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

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

    // optional string access_token_secret = 6;


    pub fn get_access_token_secret(&self) -> &str {
        match self.access_token_secret.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_access_token_secret(&mut self) {
        self.access_token_secret.clear();
    }

    pub fn has_access_token_secret(&self) -> bool {
        self.access_token_secret.is_some()
    }

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

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

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

    // optional bool is_valid = 7;


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

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.external_type, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.external_id)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.external_user_name)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.external_url)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.access_token)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.access_token_secret)?;
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_valid = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.external_type {
            my_size += ::protobuf::rt::enum_size(1, v);
        }
        if let Some(ref v) = self.external_id.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(ref v) = self.external_user_name.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(ref v) = self.external_url.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        if let Some(ref v) = self.access_token.as_ref() {
            my_size += ::protobuf::rt::string_size(5, &v);
        }
        if let Some(ref v) = self.access_token_secret.as_ref() {
            my_size += ::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.is_valid {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.external_type {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&v))?;
        }
        if let Some(ref v) = self.external_id.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(ref v) = self.external_user_name.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(ref v) = self.external_url.as_ref() {
            os.write_string(4, &v)?;
        }
        if let Some(ref v) = self.access_token.as_ref() {
            os.write_string(5, &v)?;
        }
        if let Some(ref v) = self.access_token_secret.as_ref() {
            os.write_string(6, &v)?;
        }
        if let Some(v) = self.is_valid {
            os.write_bool(7, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EExternalAccountType>>(
                "external_type",
                |m: &CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response| { &m.external_type },
                |m: &mut CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response| { &mut m.external_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "external_id",
                |m: &CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response| { &m.external_id },
                |m: &mut CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response| { &mut m.external_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "external_user_name",
                |m: &CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response| { &m.external_user_name },
                |m: &mut CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response| { &mut m.external_user_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "external_url",
                |m: &CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response| { &m.external_url },
                |m: &mut CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response| { &mut m.external_url },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "access_token",
                |m: &CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response| { &m.access_token },
                |m: &mut CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response| { &mut m.access_token },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "access_token_secret",
                |m: &CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response| { &m.access_token_secret },
                |m: &mut CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response| { &mut m.access_token_secret },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_valid",
                |m: &CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response| { &m.is_valid },
                |m: &mut CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response| { &mut m.is_valid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response>(
                "CAccountLinking_GetLinkedAccountInfo_Response.CExternalAccountTuple_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CAccountLinking_GetLinkedAccountInfo_Response_CExternalAccountTuple_Response {
    fn clear(&mut self) {
        self.external_type = ::std::option::Option::None;
        self.external_id.clear();
        self.external_user_name.clear();
        self.external_url.clear();
        self.access_token.clear();
        self.access_token_secret.clear();
        self.is_valid = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CEmbeddedClient_AuthorizeCurrentDevice_Request {
    // message fields
    steamid: ::std::option::Option<u64>,
    appid: ::std::option::Option<u32>,
    device_info: ::protobuf::SingularField<::std::string::String>,
    deviceid: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

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

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

    // optional uint32 appid = 2;


    pub fn get_appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }
    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

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

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

    // optional string device_info = 3;


    pub fn get_device_info(&self) -> &str {
        match self.device_info.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_device_info(&mut self) {
        self.device_info.clear();
    }

    pub fn has_device_info(&self) -> bool {
        self.device_info.is_some()
    }

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

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

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

    // optional uint32 deviceid = 4;


    pub fn get_deviceid(&self) -> u32 {
        self.deviceid.unwrap_or(0)
    }
    pub fn clear_deviceid(&mut self) {
        self.deviceid = ::std::option::Option::None;
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.appid = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.device_info)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.deviceid = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(2, v)?;
        }
        if let Some(ref v) = self.device_info.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(v) = self.deviceid {
            os.write_uint32(4, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

impl ::protobuf::Clear for CEmbeddedClient_AuthorizeCurrentDevice_Request {
    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.appid = ::std::option::Option::None;
        self.device_info.clear();
        self.deviceid = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CEmbeddedClient_Token {
    // message fields
    steamid: ::std::option::Option<u64>,
    client_token: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    expiry: ::std::option::Option<u32>,
    deviceid: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

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

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

    // optional bytes client_token = 2;


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

    pub fn has_client_token(&self) -> bool {
        self.client_token.is_some()
    }

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

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

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

    // optional uint32 expiry = 3;


    pub fn get_expiry(&self) -> u32 {
        self.expiry.unwrap_or(0)
    }
    pub fn clear_expiry(&mut self) {
        self.expiry = ::std::option::Option::None;
    }

    pub fn has_expiry(&self) -> bool {
        self.expiry.is_some()
    }

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

    // optional uint32 deviceid = 4;


    pub fn get_deviceid(&self) -> u32 {
        self.deviceid.unwrap_or(0)
    }
    pub fn clear_deviceid(&mut self) {
        self.deviceid = ::std::option::Option::None;
    }

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(ref v) = self.client_token.as_ref() {
            os.write_bytes(2, &v)?;
        }
        if let Some(v) = self.expiry {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.deviceid {
            os.write_uint32(4, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

impl ::protobuf::Clear for CEmbeddedClient_Token {
    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.client_token.clear();
        self.expiry = ::std::option::Option::None;
        self.deviceid = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CEmbeddedClient_AuthorizeDevice_Response {
    // message fields
    result: ::std::option::Option<u32>,
    pub token: ::protobuf::SingularPtrField<CEmbeddedClient_Token>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 result = 1;


    pub fn get_result(&self) -> u32 {
        self.result.unwrap_or(0)
    }
    pub fn clear_result(&mut self) {
        self.result = ::std::option::Option::None;
    }

    pub fn has_result(&self) -> bool {
        self.result.is_some()
    }

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

    // optional .CEmbeddedClient_Token token = 2;


    pub fn get_token(&self) -> &CEmbeddedClient_Token {
        self.token.as_ref().unwrap_or_else(|| <CEmbeddedClient_Token as ::protobuf::Message>::default_instance())
    }
    pub fn clear_token(&mut self) {
        self.token.clear();
    }

    pub fn has_token(&self) -> bool {
        self.token.is_some()
    }

    // Param is passed by value, moved
    pub fn set_token(&mut self, v: CEmbeddedClient_Token) {
        self.token = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_token(&mut self) -> &mut CEmbeddedClient_Token {
        if self.token.is_none() {
            self.token.set_default();
        }
        self.token.as_mut().unwrap()
    }

    // Take field
    pub fn take_token(&mut self) -> CEmbeddedClient_Token {
        self.token.take().unwrap_or_else(|| CEmbeddedClient_Token::new())
    }
}

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.result {
            os.write_uint32(1, v)?;
        }
        if let Some(ref v) = self.token.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum EInternalAccountType {
    k_EInternalSteamAccountType = 1,
    k_EInternalClanType = 2,
    k_EInternalAppType = 3,
    k_EInternalBroadcastChannelType = 4,
}

impl ::protobuf::ProtobufEnum for EInternalAccountType {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<EInternalAccountType> {
        match value {
            1 => ::std::option::Option::Some(EInternalAccountType::k_EInternalSteamAccountType),
            2 => ::std::option::Option::Some(EInternalAccountType::k_EInternalClanType),
            3 => ::std::option::Option::Some(EInternalAccountType::k_EInternalAppType),
            4 => ::std::option::Option::Some(EInternalAccountType::k_EInternalBroadcastChannelType),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [EInternalAccountType] = &[
            EInternalAccountType::k_EInternalSteamAccountType,
            EInternalAccountType::k_EInternalClanType,
            EInternalAccountType::k_EInternalAppType,
            EInternalAccountType::k_EInternalBroadcastChannelType,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<EInternalAccountType>("EInternalAccountType", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for EInternalAccountType {
}

// Note, `Default` is implemented although default value is not 0
impl ::std::default::Default for EInternalAccountType {
    fn default() -> Self {
        EInternalAccountType::k_EInternalSteamAccountType
    }
}

impl ::protobuf::reflect::ProtobufValue for EInternalAccountType {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum EExternalAccountType {
    k_EExternalNone = 0,
    k_EExternalSteamAccount = 1,
    k_EExternalGoogleAccount = 2,
    k_EExternalFacebookAccount = 3,
    k_EExternalTwitterAccount = 4,
    k_EExternalTwitchAccount = 5,
    k_EExternalYouTubeChannelAccount = 6,
    k_EExternalFacebookPage = 7,
}

impl ::protobuf::ProtobufEnum for EExternalAccountType {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<EExternalAccountType> {
        match value {
            0 => ::std::option::Option::Some(EExternalAccountType::k_EExternalNone),
            1 => ::std::option::Option::Some(EExternalAccountType::k_EExternalSteamAccount),
            2 => ::std::option::Option::Some(EExternalAccountType::k_EExternalGoogleAccount),
            3 => ::std::option::Option::Some(EExternalAccountType::k_EExternalFacebookAccount),
            4 => ::std::option::Option::Some(EExternalAccountType::k_EExternalTwitterAccount),
            5 => ::std::option::Option::Some(EExternalAccountType::k_EExternalTwitchAccount),
            6 => ::std::option::Option::Some(EExternalAccountType::k_EExternalYouTubeChannelAccount),
            7 => ::std::option::Option::Some(EExternalAccountType::k_EExternalFacebookPage),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [EExternalAccountType] = &[
            EExternalAccountType::k_EExternalNone,
            EExternalAccountType::k_EExternalSteamAccount,
            EExternalAccountType::k_EExternalGoogleAccount,
            EExternalAccountType::k_EExternalFacebookAccount,
            EExternalAccountType::k_EExternalTwitterAccount,
            EExternalAccountType::k_EExternalTwitchAccount,
            EExternalAccountType::k_EExternalYouTubeChannelAccount,
            EExternalAccountType::k_EExternalFacebookPage,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<EExternalAccountType>("EExternalAccountType", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for EExternalAccountType {
}

impl ::std::default::Default for EExternalAccountType {
    fn default() -> Self {
        EExternalAccountType::k_EExternalNone
    }
}

impl ::protobuf::reflect::ProtobufValue for EExternalAccountType {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n+steammessages_useraccount.steamclient.proto\x1a,steammessages_unified\
    _base.steamclient.proto\"]\n8CUserAccount_GetAvailableValveDiscountPromo\
    tions_Request\x12!\n\x0ccountry_code\x18\x01\x20\x01(\tR\x0bcountryCode\
    \"\xe0\x05\n9CUserAccount_GetAvailableValveDiscountPromotions_Response\
    \x12x\n\npromotions\x18\x01\x20\x03(\x0b2X.CUserAccount_GetAvailableValv\
    eDiscountPromotions_Response.ValveDiscountPromotionDetailsR\npromotions\
    \x1a\xa8\x04\n\x1dValveDiscountPromotionDetails\x12\x20\n\x0bpromotionid\
    \x18\x01\x20\x01(\rR\x0bpromotionid\x123\n\x15promotion_description\x18\
    \x02\x20\x01(\tR\x14promotionDescription\x12.\n\x13minimum_cart_amount\
    \x18\x03\x20\x01(\x03R\x11minimumCartAmount\x12D\n\x1fminimum_cart_amoun\
    t_for_display\x18\x04\x20\x01(\x03R\x1bminimumCartAmountForDisplay\x12'\
    \n\x0fdiscount_amount\x18\x05\x20\x01(\x03R\x0ediscountAmount\x12#\n\rcu\
    rrency_code\x18\x06\x20\x01(\x05R\x0ccurrencyCode\x12.\n\x13available_us\
    e_count\x18\x07\x20\x01(\x05R\x11availableUseCount\x12:\n\x19promotional\
    _discount_type\x18\x08\x20\x01(\x05R\x17promotionalDiscountType\x12*\n\
    \x11loyalty_reward_id\x18\t\x20\x01(\x05R\x0floyaltyRewardId\x120\n\x14l\
    ocalized_name_token\x18\n\x20\x01(\tR\x12localizedNameToken\x12\"\n\rmax\
    _use_count\x18\x0b\x20\x01(\x05R\x0bmaxUseCount\"+\n)CUserAccount_GetAcc\
    ountLinkStatus_Request\"\xb3\x01\n*CUserAccount_GetAccountLinkStatus_Res\
    ponse\x12\x12\n\x04pwid\x18\x01\x20\x01(\rR\x04pwid\x123\n\x15identity_v\
    erification\x18\x02\x20\x01(\rR\x14identityVerification\x12<\n\x1aperfor\
    med_age_verification\x18\x03\x20\x01(\x08R\x18performedAgeVerification\"\
    @\n(CUserAccount_CancelLicenseForApp_Request\x12\x14\n\x05appid\x18\x01\
    \x20\x01(\rR\x05appid\"+\n)CUserAccount_CancelLicenseForApp_Response\"\
    \x9b\x01\n,CUserAccount_CreateFriendInviteToken_Request\x12!\n\x0cinvite\
    _limit\x18\x01\x20\x01(\rR\x0binviteLimit\x12'\n\x0finvite_duration\x18\
    \x02\x20\x01(\rR\x0einviteDuration\x12\x1f\n\x0binvite_note\x18\x03\x20\
    \x01(\tR\ninviteNote\"\xd7\x01\n-CUserAccount_CreateFriendInviteToken_Re\
    sponse\x12!\n\x0cinvite_token\x18\x01\x20\x01(\tR\x0binviteToken\x12!\n\
    \x0cinvite_limit\x18\x02\x20\x01(\x04R\x0binviteLimit\x12'\n\x0finvite_d\
    uration\x18\x03\x20\x01(\x04R\x0einviteDuration\x12!\n\x0ctime_created\
    \x18\x04\x20\x01(\x07R\x0btimeCreated\x12\x14\n\x05valid\x18\x05\x20\x01\
    (\x08R\x05valid\",\n*CUserAccount_GetFriendInviteTokens_Request\"u\n+CUs\
    erAccount_GetFriendInviteTokens_Response\x12F\n\x06tokens\x18\x01\x20\
    \x03(\x0b2..CUserAccount_CreateFriendInviteToken_ResponseR\x06tokens\"i\
    \n*CUserAccount_ViewFriendInviteToken_Request\x12\x18\n\x07steamid\x18\
    \x01\x20\x01(\x06R\x07steamid\x12!\n\x0cinvite_token\x18\x02\x20\x01(\tR\
    \x0binviteToken\"\x86\x01\n+CUserAccount_ViewFriendInviteToken_Response\
    \x12\x14\n\x05valid\x18\x01\x20\x01(\x08R\x05valid\x12\x18\n\x07steamid\
    \x18\x02\x20\x01(\x04R\x07steamid\x12'\n\x0finvite_duration\x18\x03\x20\
    \x01(\x04R\x0einviteDuration\"k\n,CUserAccount_RedeemFriendInviteToken_R\
    equest\x12\x18\n\x07steamid\x18\x01\x20\x01(\x06R\x07steamid\x12!\n\x0ci\
    nvite_token\x18\x02\x20\x01(\tR\x0binviteToken\"/\n-CUserAccount_RedeemF\
    riendInviteToken_Response\"Q\n,CUserAccount_RevokeFriendInviteToken_Requ\
    est\x12!\n\x0cinvite_token\x18\x01\x20\x01(\tR\x0binviteToken\"/\n-CUser\
    Account_RevokeFriendInviteToken_Response\"J\n'CUserAccount_RegisterCompa\
    tTool_Request\x12\x1f\n\x0bcompat_tool\x18\x01\x20\x01(\rR\ncompatTool\"\
    *\n(CUserAccount_RegisterCompatTool_Response\"\xd0\x03\n,CAccountLinking\
    _GetLinkedAccountInfo_Request\x12U\n\x0caccount_type\x18\x01\x20\x01(\
    \x0e2\x15.EInternalAccountType:\x1bk_EInternalSteamAccountTypeR\x0baccou\
    ntType\x126\n\naccount_id\x18\x02\x20\x01(\x04R\taccountIdB\x17\x82\xb5\
    \x18\x13Internal\x20account\x20ID\x12|\n\x06filter\x18\x03\x20\x01(\x0e2\
    \x15.EExternalAccountType:\x0fk_EExternalNoneR\x06filterB<\x82\xb5\x188i\
    f\x20specified\x20then\x20only\x20return\x20this\x20external\x20account\
    \x20type\x12\x92\x01\n\x13return_access_token\x18\x04\x20\x01(\x08R\x11r\
    eturnAccessTokenBb\x82\xb5\x18^if\x20provided\x20and\x20true,\x20then\
    \x20returns\x20valid\x20access\x20token\x20if\x20available.\x20It\x20may\
    \x20refresh\x20the\x20token.\x20\"\xff\x06\n-CAccountLinking_GetLinkedAc\
    countInfo_Response\x12z\n\x11external_accounts\x18\x01\x20\x03(\x0b2M.CA\
    ccountLinking_GetLinkedAccountInfo_Response.CExternalAccountTuple_Respon\
    seR\x10externalAccounts\x1a\xd1\x05\n\x1eCExternalAccountTuple_Response\
    \x12K\n\rexternal_type\x18\x01\x20\x01(\x0e2\x15.EExternalAccountType:\
    \x0fk_EExternalNoneR\x0cexternalType\x12G\n\x0bexternal_id\x18\x02\x20\
    \x01(\tR\nexternalIdB&\x82\xb5\x18\"unique\x20external\x20account\x20ide\
    ntifier\x12L\n\x12external_user_name\x18\x03\x20\x01(\tR\x10externalUser\
    NameB\x1e\x82\xb5\x18\x1auser\x20readable;\x20best\x20effort\x12`\n\x0ce\
    xternal_url\x18\x04\x20\x01(\tR\x0bexternalUrlB=\x82\xb5\x189required\
    \x20for\x20all,\x20can\x20be\x20a\x20sentinal\x20to\x20verify\x20correct\
    ness\x12M\n\x0caccess_token\x18\x05\x20\x01(\tR\x0baccessTokenB*\x82\xb5\
    \x18&provided\x20if\x20requeest\x20and\x20it\x20was\x20valid.\x12~\n\x13\
    access_token_secret\x18\x06\x20\x01(\tR\x11accessTokenSecretBN\x82\xb5\
    \x18Jrequired\x20for\x20OAuth\x20v1\x20and\x20signing\x20the\x20message,\
    \x20provided\x20with\x20access\x20token.\x12\x99\x01\n\x08is_valid\x18\
    \x07\x20\x01(\x08R\x07isValidB~\x82\xb5\x18zIf\x20false,\x20it\x20means\
    \x20access\x20token\x20no\x20longer\x20work\x20(expired,\x20disconnected\
    )\x20and\x20the\x20link\x20is\x20now\x20broken.\x20Inform\x20user\x20to\
    \x20refresh.\"\x9d\x01\n.CEmbeddedClient_AuthorizeCurrentDevice_Request\
    \x12\x18\n\x07steamid\x18\x01\x20\x01(\x06R\x07steamid\x12\x14\n\x05appi\
    d\x18\x02\x20\x01(\rR\x05appid\x12\x1f\n\x0bdevice_info\x18\x03\x20\x01(\
    \tR\ndeviceInfo\x12\x1a\n\x08deviceid\x18\x04\x20\x01(\rR\x08deviceid\"\
    \x88\x01\n\x15CEmbeddedClient_Token\x12\x18\n\x07steamid\x18\x01\x20\x01\
    (\x06R\x07steamid\x12!\n\x0cclient_token\x18\x02\x20\x01(\x0cR\x0bclient\
    Token\x12\x16\n\x06expiry\x18\x03\x20\x01(\rR\x06expiry\x12\x1a\n\x08dev\
    iceid\x18\x04\x20\x01(\rR\x08deviceid\"p\n(CEmbeddedClient_AuthorizeDevi\
    ce_Response\x12\x16\n\x06result\x18\x01\x20\x01(\rR\x06result\x12,\n\x05\
    token\x18\x02\x20\x01(\x0b2\x16.CEmbeddedClient_TokenR\x05token*\x8d\x01\
    \n\x14EInternalAccountType\x12\x1f\n\x1bk_EInternalSteamAccountType\x10\
    \x01\x12\x17\n\x13k_EInternalClanType\x10\x02\x12\x16\n\x12k_EInternalAp\
    pType\x10\x03\x12#\n\x1fk_EInternalBroadcastChannelType\x10\x04*\x86\x02\
    \n\x14EExternalAccountType\x12\x13\n\x0fk_EExternalNone\x10\0\x12\x1b\n\
    \x17k_EExternalSteamAccount\x10\x01\x12\x1c\n\x18k_EExternalGoogleAccoun\
    t\x10\x02\x12\x1e\n\x1ak_EExternalFacebookAccount\x10\x03\x12\x1d\n\x19k\
    _EExternalTwitterAccount\x10\x04\x12\x1c\n\x18k_EExternalTwitchAccount\
    \x10\x05\x12$\n\x20k_EExternalYouTubeChannelAccount\x10\x06\x12\x1b\n\
    \x17k_EExternalFacebookPage\x10\x072\xcb\x0c\n\x0bUserAccount\x12\xe0\
    \x01\n#GetAvailableValveDiscountPromotions\x129.CUserAccount_GetAvailabl\
    eValveDiscountPromotions_Request\x1a:.CUserAccount_GetAvailableValveDisc\
    ountPromotions_Response\"B\x82\xb5\x18>Gets\x20the\x20available\x20promo\
    tional\x20discounts\x20available\x20to\x20the\x20user\x12\x90\x01\n\x14G\
    etAccountLinkStatus\x12*.CUserAccount_GetAccountLinkStatus_Request\x1a+.\
    CUserAccount_GetAccountLinkStatus_Response\"\x1f\x82\xb5\x18\x1bFetches\
    \x20account\x20link\x20status\x12\x93\x01\n\x13CancelLicenseForApp\x12).\
    CUserAccount_CancelLicenseForApp_Request\x1a*.CUserAccount_CancelLicense\
    ForApp_Response\"%\x82\xb5\x18!Cancels\x20a\x20free\x20license\x20for\
    \x20a\x20user\x12\xc4\x01\n\x17CreateFriendInviteToken\x12-.CUserAccount\
    _CreateFriendInviteToken_Request\x1a..CUserAccount_CreateFriendInviteTok\
    en_Response\"J\x82\xb5\x18FCreate\x20a\x20limited-use\x20token\x20that\
    \x20can\x20be\x20used\x20to\x20create\x20a\x20friend\x20request\x12\xa1\
    \x01\n\x15GetFriendInviteTokens\x12+.CUserAccount_GetFriendInviteTokens_\
    Request\x1a,.CUserAccount_GetFriendInviteTokens_Response\"-\x82\xb5\x18)\
    Get\x20the\x20set\x20of\x20active\x20tokens\x20for\x20the\x20user\x12\
    \x9b\x01\n\x15ViewFriendInviteToken\x12+.CUserAccount_ViewFriendInviteTo\
    ken_Request\x1a,.CUserAccount_ViewFriendInviteToken_Response\"'\x82\xb5\
    \x18#View\x20details\x20about\x20an\x20invite\x20token\x20\x12\xb7\x01\n\
    \x17RedeemFriendInviteToken\x12-.CUserAccount_RedeemFriendInviteToken_Re\
    quest\x1a..CUserAccount_RedeemFriendInviteToken_Response\"=\x82\xb5\x189\
    Create\x20a\x20friend\x20relationship\x20using\x20the\x20given\x20invite\
    \x20token\x12\xa2\x01\n\x17RevokeFriendInviteToken\x12-.CUserAccount_Rev\
    okeFriendInviteToken_Request\x1a..CUserAccount_RevokeFriendInviteToken_R\
    esponse\"(\x82\xb5\x18$Revoke\x20an\x20active\x20friend\x20invite\x20tok\
    en\x12\x98\x01\n\x12RegisterCompatTool\x12(.CUserAccount_RegisterCompatT\
    ool_Request\x1a).CUserAccount_RegisterCompatTool_Response\"-\x82\xb5\x18\
    )Register\x20intended\x20account\x20usage\x20of\x20a\x20tool\x1a-\x82\
    \xb5\x18)A\x20service\x20to\x20get\x20user\x20account\x20information2\
    \x9d\x02\n\x0eAccountLinking\x12\xd3\x01\n\x14GetLinkedAccountInfo\x12-.\
    CAccountLinking_GetLinkedAccountInfo_Request\x1a..CAccountLinking_GetLin\
    kedAccountInfo_Response\"\\\x82\xb5\x18XList\x20all\x20my\x20active\x20l\
    inked\x20external\x20accounts;\x20may\x20be\x20requested\x20to\x20return\
    \x20the\x20access\x20token\x1a5\x82\xb5\x181A\x20service\x20to\x20manage\
    \x20and\x20link\x20to\x20external\x20accounts2\xa4\x02\n\x0eEmbeddedClie\
    nt\x12\xc1\x01\n\x16AuthorizeCurrentDevice\x12/.CEmbeddedClient_Authoriz\
    eCurrentDevice_Request\x1a).CEmbeddedClient_AuthorizeDevice_Response\"K\
    \x82\xb5\x18GUse\x20a\x20logged-in\x20(password/etc)\x20session\x20to\
    \x20create\x20a\x20durable\x20access\x20token\x1aN\x82\xb5\x18JService\
    \x20to\x20authorize\x20and\x20manage\x20Steam\x20functions\x20directly\
    \x20embedded\x20in\x20gamesB\x03\x80\x01\x01J\xc86\n\x07\x12\x05\0\0\xd0\
    \x01\x01\n\t\n\x02\x03\0\x12\x03\0\06\n\x08\n\x01\x08\x12\x03\x02\0\"\n\
    \t\n\x02\x08\x10\x12\x03\x02\0\"\n\n\n\x02\x05\0\x12\x04\x04\0\t\x01\n\n\
    \n\x03\x05\0\x01\x12\x03\x04\x05\x19\n\x0b\n\x04\x05\0\x02\0\x12\x03\x05\
    \x08(\n\x0c\n\x05\x05\0\x02\0\x01\x12\x03\x05\x08#\n\x0c\n\x05\x05\0\x02\
    \0\x02\x12\x03\x05&'\n\x0b\n\x04\x05\0\x02\x01\x12\x03\x06\x08\x20\n\x0c\
    \n\x05\x05\0\x02\x01\x01\x12\x03\x06\x08\x1b\n\x0c\n\x05\x05\0\x02\x01\
    \x02\x12\x03\x06\x1e\x1f\n\x0b\n\x04\x05\0\x02\x02\x12\x03\x07\x08\x1f\n\
    \x0c\n\x05\x05\0\x02\x02\x01\x12\x03\x07\x08\x1a\n\x0c\n\x05\x05\0\x02\
    \x02\x02\x12\x03\x07\x1d\x1e\n\x0b\n\x04\x05\0\x02\x03\x12\x03\x08\x08,\
    \n\x0c\n\x05\x05\0\x02\x03\x01\x12\x03\x08\x08'\n\x0c\n\x05\x05\0\x02\
    \x03\x02\x12\x03\x08*+\n\n\n\x02\x05\x01\x12\x04\x0b\0\x14\x01\n\n\n\x03\
    \x05\x01\x01\x12\x03\x0b\x05\x19\n\x0b\n\x04\x05\x01\x02\0\x12\x03\x0c\
    \x08\x1c\n\x0c\n\x05\x05\x01\x02\0\x01\x12\x03\x0c\x08\x17\n\x0c\n\x05\
    \x05\x01\x02\0\x02\x12\x03\x0c\x1a\x1b\n\x0b\n\x04\x05\x01\x02\x01\x12\
    \x03\r\x08$\n\x0c\n\x05\x05\x01\x02\x01\x01\x12\x03\r\x08\x1f\n\x0c\n\
    \x05\x05\x01\x02\x01\x02\x12\x03\r\"#\n\x0b\n\x04\x05\x01\x02\x02\x12\
    \x03\x0e\x08%\n\x0c\n\x05\x05\x01\x02\x02\x01\x12\x03\x0e\x08\x20\n\x0c\
    \n\x05\x05\x01\x02\x02\x02\x12\x03\x0e#$\n\x0b\n\x04\x05\x01\x02\x03\x12\
    \x03\x0f\x08'\n\x0c\n\x05\x05\x01\x02\x03\x01\x12\x03\x0f\x08\"\n\x0c\n\
    \x05\x05\x01\x02\x03\x02\x12\x03\x0f%&\n\x0b\n\x04\x05\x01\x02\x04\x12\
    \x03\x10\x08&\n\x0c\n\x05\x05\x01\x02\x04\x01\x12\x03\x10\x08!\n\x0c\n\
    \x05\x05\x01\x02\x04\x02\x12\x03\x10$%\n\x0b\n\x04\x05\x01\x02\x05\x12\
    \x03\x11\x08%\n\x0c\n\x05\x05\x01\x02\x05\x01\x12\x03\x11\x08\x20\n\x0c\
    \n\x05\x05\x01\x02\x05\x02\x12\x03\x11#$\n\x0b\n\x04\x05\x01\x02\x06\x12\
    \x03\x12\x08-\n\x0c\n\x05\x05\x01\x02\x06\x01\x12\x03\x12\x08(\n\x0c\n\
    \x05\x05\x01\x02\x06\x02\x12\x03\x12+,\n\x0b\n\x04\x05\x01\x02\x07\x12\
    \x03\x13\x08$\n\x0c\n\x05\x05\x01\x02\x07\x01\x12\x03\x13\x08\x1f\n\x0c\
    \n\x05\x05\x01\x02\x07\x02\x12\x03\x13\"#\n\n\n\x02\x04\0\x12\x04\x16\0\
    \x18\x01\n\n\n\x03\x04\0\x01\x12\x03\x16\x08@\n\x0b\n\x04\x04\0\x02\0\
    \x12\x03\x17\x08)\n\x0c\n\x05\x04\0\x02\0\x04\x12\x03\x17\x08\x10\n\x0c\
    \n\x05\x04\0\x02\0\x05\x12\x03\x17\x11\x17\n\x0c\n\x05\x04\0\x02\0\x01\
    \x12\x03\x17\x18$\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\x17'(\n\n\n\x02\
    \x04\x01\x12\x04\x1a\0*\x01\n\n\n\x03\x04\x01\x01\x12\x03\x1a\x08A\n\x0c\
    \n\x04\x04\x01\x03\0\x12\x04\x1b\x08'\t\n\x0c\n\x05\x04\x01\x03\0\x01\
    \x12\x03\x1b\x10-\n\r\n\x06\x04\x01\x03\0\x02\0\x12\x03\x1c\x100\n\x0e\n\
    \x07\x04\x01\x03\0\x02\0\x04\x12\x03\x1c\x10\x18\n\x0e\n\x07\x04\x01\x03\
    \0\x02\0\x05\x12\x03\x1c\x19\x1f\n\x0e\n\x07\x04\x01\x03\0\x02\0\x01\x12\
    \x03\x1c\x20+\n\x0e\n\x07\x04\x01\x03\0\x02\0\x03\x12\x03\x1c./\n\r\n\
    \x06\x04\x01\x03\0\x02\x01\x12\x03\x1d\x10:\n\x0e\n\x07\x04\x01\x03\0\
    \x02\x01\x04\x12\x03\x1d\x10\x18\n\x0e\n\x07\x04\x01\x03\0\x02\x01\x05\
    \x12\x03\x1d\x19\x1f\n\x0e\n\x07\x04\x01\x03\0\x02\x01\x01\x12\x03\x1d\
    \x205\n\x0e\n\x07\x04\x01\x03\0\x02\x01\x03\x12\x03\x1d89\n\r\n\x06\x04\
    \x01\x03\0\x02\x02\x12\x03\x1e\x107\n\x0e\n\x07\x04\x01\x03\0\x02\x02\
    \x04\x12\x03\x1e\x10\x18\n\x0e\n\x07\x04\x01\x03\0\x02\x02\x05\x12\x03\
    \x1e\x19\x1e\n\x0e\n\x07\x04\x01\x03\0\x02\x02\x01\x12\x03\x1e\x1f2\n\
    \x0e\n\x07\x04\x01\x03\0\x02\x02\x03\x12\x03\x1e56\n\r\n\x06\x04\x01\x03\
    \0\x02\x03\x12\x03\x1f\x10C\n\x0e\n\x07\x04\x01\x03\0\x02\x03\x04\x12\
    \x03\x1f\x10\x18\n\x0e\n\x07\x04\x01\x03\0\x02\x03\x05\x12\x03\x1f\x19\
    \x1e\n\x0e\n\x07\x04\x01\x03\0\x02\x03\x01\x12\x03\x1f\x1f>\n\x0e\n\x07\
    \x04\x01\x03\0\x02\x03\x03\x12\x03\x1fAB\n\r\n\x06\x04\x01\x03\0\x02\x04\
    \x12\x03\x20\x103\n\x0e\n\x07\x04\x01\x03\0\x02\x04\x04\x12\x03\x20\x10\
    \x18\n\x0e\n\x07\x04\x01\x03\0\x02\x04\x05\x12\x03\x20\x19\x1e\n\x0e\n\
    \x07\x04\x01\x03\0\x02\x04\x01\x12\x03\x20\x1f.\n\x0e\n\x07\x04\x01\x03\
    \0\x02\x04\x03\x12\x03\x2012\n\r\n\x06\x04\x01\x03\0\x02\x05\x12\x03!\
    \x101\n\x0e\n\x07\x04\x01\x03\0\x02\x05\x04\x12\x03!\x10\x18\n\x0e\n\x07\
    \x04\x01\x03\0\x02\x05\x05\x12\x03!\x19\x1e\n\x0e\n\x07\x04\x01\x03\0\
    \x02\x05\x01\x12\x03!\x1f,\n\x0e\n\x07\x04\x01\x03\0\x02\x05\x03\x12\x03\
    !/0\n\r\n\x06\x04\x01\x03\0\x02\x06\x12\x03\"\x107\n\x0e\n\x07\x04\x01\
    \x03\0\x02\x06\x04\x12\x03\"\x10\x18\n\x0e\n\x07\x04\x01\x03\0\x02\x06\
    \x05\x12\x03\"\x19\x1e\n\x0e\n\x07\x04\x01\x03\0\x02\x06\x01\x12\x03\"\
    \x1f2\n\x0e\n\x07\x04\x01\x03\0\x02\x06\x03\x12\x03\"56\n\r\n\x06\x04\
    \x01\x03\0\x02\x07\x12\x03#\x10=\n\x0e\n\x07\x04\x01\x03\0\x02\x07\x04\
    \x12\x03#\x10\x18\n\x0e\n\x07\x04\x01\x03\0\x02\x07\x05\x12\x03#\x19\x1e\
    \n\x0e\n\x07\x04\x01\x03\0\x02\x07\x01\x12\x03#\x1f8\n\x0e\n\x07\x04\x01\
    \x03\0\x02\x07\x03\x12\x03#;<\n\r\n\x06\x04\x01\x03\0\x02\x08\x12\x03$\
    \x105\n\x0e\n\x07\x04\x01\x03\0\x02\x08\x04\x12\x03$\x10\x18\n\x0e\n\x07\
    \x04\x01\x03\0\x02\x08\x05\x12\x03$\x19\x1e\n\x0e\n\x07\x04\x01\x03\0\
    \x02\x08\x01\x12\x03$\x1f0\n\x0e\n\x07\x04\x01\x03\0\x02\x08\x03\x12\x03\
    $34\n\r\n\x06\x04\x01\x03\0\x02\t\x12\x03%\x10:\n\x0e\n\x07\x04\x01\x03\
    \0\x02\t\x04\x12\x03%\x10\x18\n\x0e\n\x07\x04\x01\x03\0\x02\t\x05\x12\
    \x03%\x19\x1f\n\x0e\n\x07\x04\x01\x03\0\x02\t\x01\x12\x03%\x204\n\x0e\n\
    \x07\x04\x01\x03\0\x02\t\x03\x12\x03%79\n\r\n\x06\x04\x01\x03\0\x02\n\
    \x12\x03&\x102\n\x0e\n\x07\x04\x01\x03\0\x02\n\x04\x12\x03&\x10\x18\n\
    \x0e\n\x07\x04\x01\x03\0\x02\n\x05\x12\x03&\x19\x1e\n\x0e\n\x07\x04\x01\
    \x03\0\x02\n\x01\x12\x03&\x1f,\n\x0e\n\x07\x04\x01\x03\0\x02\n\x03\x12\
    \x03&/1\n\x0b\n\x04\x04\x01\x02\0\x12\x03)\x08y\n\x0c\n\x05\x04\x01\x02\
    \0\x04\x12\x03)\x08\x10\n\x0c\n\x05\x04\x01\x02\0\x06\x12\x03)\x11i\n\
    \x0c\n\x05\x04\x01\x02\0\x01\x12\x03)jt\n\x0c\n\x05\x04\x01\x02\0\x03\
    \x12\x03)wx\n\n\n\x02\x04\x02\x12\x04,\0-\x01\n\n\n\x03\x04\x02\x01\x12\
    \x03,\x081\n\n\n\x02\x04\x03\x12\x04/\03\x01\n\n\n\x03\x04\x03\x01\x12\
    \x03/\x082\n\x0b\n\x04\x04\x03\x02\0\x12\x030\x08!\n\x0c\n\x05\x04\x03\
    \x02\0\x04\x12\x030\x08\x10\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x030\x11\
    \x17\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x030\x18\x1c\n\x0c\n\x05\x04\x03\
    \x02\0\x03\x12\x030\x1f\x20\n\x0b\n\x04\x04\x03\x02\x01\x12\x031\x082\n\
    \x0c\n\x05\x04\x03\x02\x01\x04\x12\x031\x08\x10\n\x0c\n\x05\x04\x03\x02\
    \x01\x05\x12\x031\x11\x17\n\x0c\n\x05\x04\x03\x02\x01\x01\x12\x031\x18-\
    \n\x0c\n\x05\x04\x03\x02\x01\x03\x12\x03101\n\x0b\n\x04\x04\x03\x02\x02\
    \x12\x032\x085\n\x0c\n\x05\x04\x03\x02\x02\x04\x12\x032\x08\x10\n\x0c\n\
    \x05\x04\x03\x02\x02\x05\x12\x032\x11\x15\n\x0c\n\x05\x04\x03\x02\x02\
    \x01\x12\x032\x160\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03234\n\n\n\x02\
    \x04\x04\x12\x045\07\x01\n\n\n\x03\x04\x04\x01\x12\x035\x080\n\x0b\n\x04\
    \x04\x04\x02\0\x12\x036\x08\"\n\x0c\n\x05\x04\x04\x02\0\x04\x12\x036\x08\
    \x10\n\x0c\n\x05\x04\x04\x02\0\x05\x12\x036\x11\x17\n\x0c\n\x05\x04\x04\
    \x02\0\x01\x12\x036\x18\x1d\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x036\x20!\
    \n\n\n\x02\x04\x05\x12\x049\0:\x01\n\n\n\x03\x04\x05\x01\x12\x039\x081\n\
    \n\n\x02\x04\x06\x12\x04<\0@\x01\n\n\n\x03\x04\x06\x01\x12\x03<\x084\n\
    \x0b\n\x04\x04\x06\x02\0\x12\x03=\x08)\n\x0c\n\x05\x04\x06\x02\0\x04\x12\
    \x03=\x08\x10\n\x0c\n\x05\x04\x06\x02\0\x05\x12\x03=\x11\x17\n\x0c\n\x05\
    \x04\x06\x02\0\x01\x12\x03=\x18$\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03='\
    (\n\x0b\n\x04\x04\x06\x02\x01\x12\x03>\x08,\n\x0c\n\x05\x04\x06\x02\x01\
    \x04\x12\x03>\x08\x10\n\x0c\n\x05\x04\x06\x02\x01\x05\x12\x03>\x11\x17\n\
    \x0c\n\x05\x04\x06\x02\x01\x01\x12\x03>\x18'\n\x0c\n\x05\x04\x06\x02\x01\
    \x03\x12\x03>*+\n\x0b\n\x04\x04\x06\x02\x02\x12\x03?\x08(\n\x0c\n\x05\
    \x04\x06\x02\x02\x04\x12\x03?\x08\x10\n\x0c\n\x05\x04\x06\x02\x02\x05\
    \x12\x03?\x11\x17\n\x0c\n\x05\x04\x06\x02\x02\x01\x12\x03?\x18#\n\x0c\n\
    \x05\x04\x06\x02\x02\x03\x12\x03?&'\n\n\n\x02\x04\x07\x12\x04B\0H\x01\n\
    \n\n\x03\x04\x07\x01\x12\x03B\x085\n\x0b\n\x04\x04\x07\x02\0\x12\x03C\
    \x08)\n\x0c\n\x05\x04\x07\x02\0\x04\x12\x03C\x08\x10\n\x0c\n\x05\x04\x07\
    \x02\0\x05\x12\x03C\x11\x17\n\x0c\n\x05\x04\x07\x02\0\x01\x12\x03C\x18$\
    \n\x0c\n\x05\x04\x07\x02\0\x03\x12\x03C'(\n\x0b\n\x04\x04\x07\x02\x01\
    \x12\x03D\x08)\n\x0c\n\x05\x04\x07\x02\x01\x04\x12\x03D\x08\x10\n\x0c\n\
    \x05\x04\x07\x02\x01\x05\x12\x03D\x11\x17\n\x0c\n\x05\x04\x07\x02\x01\
    \x01\x12\x03D\x18$\n\x0c\n\x05\x04\x07\x02\x01\x03\x12\x03D'(\n\x0b\n\
    \x04\x04\x07\x02\x02\x12\x03E\x08,\n\x0c\n\x05\x04\x07\x02\x02\x04\x12\
    \x03E\x08\x10\n\x0c\n\x05\x04\x07\x02\x02\x05\x12\x03E\x11\x17\n\x0c\n\
    \x05\x04\x07\x02\x02\x01\x12\x03E\x18'\n\x0c\n\x05\x04\x07\x02\x02\x03\
    \x12\x03E*+\n\x0b\n\x04\x04\x07\x02\x03\x12\x03F\x08*\n\x0c\n\x05\x04\
    \x07\x02\x03\x04\x12\x03F\x08\x10\n\x0c\n\x05\x04\x07\x02\x03\x05\x12\
    \x03F\x11\x18\n\x0c\n\x05\x04\x07\x02\x03\x01\x12\x03F\x19%\n\x0c\n\x05\
    \x04\x07\x02\x03\x03\x12\x03F()\n\x0b\n\x04\x04\x07\x02\x04\x12\x03G\x08\
    \x20\n\x0c\n\x05\x04\x07\x02\x04\x04\x12\x03G\x08\x10\n\x0c\n\x05\x04\
    \x07\x02\x04\x05\x12\x03G\x11\x15\n\x0c\n\x05\x04\x07\x02\x04\x01\x12\
    \x03G\x16\x1b\n\x0c\n\x05\x04\x07\x02\x04\x03\x12\x03G\x1e\x1f\n\n\n\x02\
    \x04\x08\x12\x04J\0K\x01\n\n\n\x03\x04\x08\x01\x12\x03J\x082\n\n\n\x02\
    \x04\t\x12\x04M\0O\x01\n\n\n\x03\x04\t\x01\x12\x03M\x083\n\x0b\n\x04\x04\
    \t\x02\0\x12\x03N\x08K\n\x0c\n\x05\x04\t\x02\0\x04\x12\x03N\x08\x10\n\
    \x0c\n\x05\x04\t\x02\0\x06\x12\x03N\x11?\n\x0c\n\x05\x04\t\x02\0\x01\x12\
    \x03N@F\n\x0c\n\x05\x04\t\x02\0\x03\x12\x03NIJ\n\n\n\x02\x04\n\x12\x04Q\
    \0T\x01\n\n\n\x03\x04\n\x01\x12\x03Q\x082\n\x0b\n\x04\x04\n\x02\0\x12\
    \x03R\x08%\n\x0c\n\x05\x04\n\x02\0\x04\x12\x03R\x08\x10\n\x0c\n\x05\x04\
    \n\x02\0\x05\x12\x03R\x11\x18\n\x0c\n\x05\x04\n\x02\0\x01\x12\x03R\x19\
    \x20\n\x0c\n\x05\x04\n\x02\0\x03\x12\x03R#$\n\x0b\n\x04\x04\n\x02\x01\
    \x12\x03S\x08)\n\x0c\n\x05\x04\n\x02\x01\x04\x12\x03S\x08\x10\n\x0c\n\
    \x05\x04\n\x02\x01\x05\x12\x03S\x11\x17\n\x0c\n\x05\x04\n\x02\x01\x01\
    \x12\x03S\x18$\n\x0c\n\x05\x04\n\x02\x01\x03\x12\x03S'(\n\n\n\x02\x04\
    \x0b\x12\x04V\0Z\x01\n\n\n\x03\x04\x0b\x01\x12\x03V\x083\n\x0b\n\x04\x04\
    \x0b\x02\0\x12\x03W\x08\x20\n\x0c\n\x05\x04\x0b\x02\0\x04\x12\x03W\x08\
    \x10\n\x0c\n\x05\x04\x0b\x02\0\x05\x12\x03W\x11\x15\n\x0c\n\x05\x04\x0b\
    \x02\0\x01\x12\x03W\x16\x1b\n\x0c\n\x05\x04\x0b\x02\0\x03\x12\x03W\x1e\
    \x1f\n\x0b\n\x04\x04\x0b\x02\x01\x12\x03X\x08$\n\x0c\n\x05\x04\x0b\x02\
    \x01\x04\x12\x03X\x08\x10\n\x0c\n\x05\x04\x0b\x02\x01\x05\x12\x03X\x11\
    \x17\n\x0c\n\x05\x04\x0b\x02\x01\x01\x12\x03X\x18\x1f\n\x0c\n\x05\x04\
    \x0b\x02\x01\x03\x12\x03X\"#\n\x0b\n\x04\x04\x0b\x02\x02\x12\x03Y\x08,\n\
    \x0c\n\x05\x04\x0b\x02\x02\x04\x12\x03Y\x08\x10\n\x0c\n\x05\x04\x0b\x02\
    \x02\x05\x12\x03Y\x11\x17\n\x0c\n\x05\x04\x0b\x02\x02\x01\x12\x03Y\x18'\
    \n\x0c\n\x05\x04\x0b\x02\x02\x03\x12\x03Y*+\n\n\n\x02\x04\x0c\x12\x04\\\
    \0_\x01\n\n\n\x03\x04\x0c\x01\x12\x03\\\x084\n\x0b\n\x04\x04\x0c\x02\0\
    \x12\x03]\x08%\n\x0c\n\x05\x04\x0c\x02\0\x04\x12\x03]\x08\x10\n\x0c\n\
    \x05\x04\x0c\x02\0\x05\x12\x03]\x11\x18\n\x0c\n\x05\x04\x0c\x02\0\x01\
    \x12\x03]\x19\x20\n\x0c\n\x05\x04\x0c\x02\0\x03\x12\x03]#$\n\x0b\n\x04\
    \x04\x0c\x02\x01\x12\x03^\x08)\n\x0c\n\x05\x04\x0c\x02\x01\x04\x12\x03^\
    \x08\x10\n\x0c\n\x05\x04\x0c\x02\x01\x05\x12\x03^\x11\x17\n\x0c\n\x05\
    \x04\x0c\x02\x01\x01\x12\x03^\x18$\n\x0c\n\x05\x04\x0c\x02\x01\x03\x12\
    \x03^'(\n\n\n\x02\x04\r\x12\x04a\0b\x01\n\n\n\x03\x04\r\x01\x12\x03a\x08\
    5\n\n\n\x02\x04\x0e\x12\x04d\0f\x01\n\n\n\x03\x04\x0e\x01\x12\x03d\x084\
    \n\x0b\n\x04\x04\x0e\x02\0\x12\x03e\x08)\n\x0c\n\x05\x04\x0e\x02\0\x04\
    \x12\x03e\x08\x10\n\x0c\n\x05\x04\x0e\x02\0\x05\x12\x03e\x11\x17\n\x0c\n\
    \x05\x04\x0e\x02\0\x01\x12\x03e\x18$\n\x0c\n\x05\x04\x0e\x02\0\x03\x12\
    \x03e'(\n\n\n\x02\x04\x0f\x12\x04h\0i\x01\n\n\n\x03\x04\x0f\x01\x12\x03h\
    \x085\n\n\n\x02\x04\x10\x12\x04k\0m\x01\n\n\n\x03\x04\x10\x01\x12\x03k\
    \x08/\n\x0b\n\x04\x04\x10\x02\0\x12\x03l\x08(\n\x0c\n\x05\x04\x10\x02\0\
    \x04\x12\x03l\x08\x10\n\x0c\n\x05\x04\x10\x02\0\x05\x12\x03l\x11\x17\n\
    \x0c\n\x05\x04\x10\x02\0\x01\x12\x03l\x18#\n\x0c\n\x05\x04\x10\x02\0\x03\
    \x12\x03l&'\n\n\n\x02\x04\x11\x12\x04o\0p\x01\n\n\n\x03\x04\x11\x01\x12\
    \x03o\x080\n\n\n\x02\x04\x12\x12\x04r\0w\x01\n\n\n\x03\x04\x12\x01\x12\
    \x03r\x084\n\x0b\n\x04\x04\x12\x02\0\x12\x03s\x08`\n\x0c\n\x05\x04\x12\
    \x02\0\x04\x12\x03s\x08\x10\n\x0c\n\x05\x04\x12\x02\0\x06\x12\x03s\x11&\
    \n\x0c\n\x05\x04\x12\x02\0\x01\x12\x03s'3\n\x0c\n\x05\x04\x12\x02\0\x03\
    \x12\x03s67\n\x0c\n\x05\x04\x12\x02\0\x08\x12\x03s8_\n\x0c\n\x05\x04\x12\
    \x02\0\x07\x12\x03sC^\n\x0b\n\x04\x04\x12\x02\x01\x12\x03t\x08O\n\x0c\n\
    \x05\x04\x12\x02\x01\x04\x12\x03t\x08\x10\n\x0c\n\x05\x04\x12\x02\x01\
    \x05\x12\x03t\x11\x17\n\x0c\n\x05\x04\x12\x02\x01\x01\x12\x03t\x18\"\n\
    \x0c\n\x05\x04\x12\x02\x01\x03\x12\x03t%&\n\x0c\n\x05\x04\x12\x02\x01\
    \x08\x12\x03t'N\n\x0f\n\x08\x04\x12\x02\x01\x08\xd0\x86\x03\x12\x03t(M\n\
    \x0c\n\x04\x04\x12\x02\x02\x12\x04u\x08\x9a\x01\n\x0c\n\x05\x04\x12\x02\
    \x02\x04\x12\x03u\x08\x10\n\x0c\n\x05\x04\x12\x02\x02\x06\x12\x03u\x11&\
    \n\x0c\n\x05\x04\x12\x02\x02\x01\x12\x03u'-\n\x0c\n\x05\x04\x12\x02\x02\
    \x03\x12\x03u01\n\r\n\x05\x04\x12\x02\x02\x08\x12\x04u2\x99\x01\n\x0c\n\
    \x05\x04\x12\x02\x02\x07\x12\x03u=L\n\x10\n\x08\x04\x12\x02\x02\x08\xd0\
    \x86\x03\x12\x04uN\x98\x01\n\x0c\n\x04\x04\x12\x02\x03\x12\x04v\x08\xa1\
    \x01\n\x0c\n\x05\x04\x12\x02\x03\x04\x12\x03v\x08\x10\n\x0c\n\x05\x04\
    \x12\x02\x03\x05\x12\x03v\x11\x15\n\x0c\n\x05\x04\x12\x02\x03\x01\x12\
    \x03v\x16)\n\x0c\n\x05\x04\x12\x02\x03\x03\x12\x03v,-\n\r\n\x05\x04\x12\
    \x02\x03\x08\x12\x04v.\xa0\x01\n\x10\n\x08\x04\x12\x02\x03\x08\xd0\x86\
    \x03\x12\x04v/\x9f\x01\n\x0b\n\x02\x04\x13\x12\x05y\0\x85\x01\x01\n\n\n\
    \x03\x04\x13\x01\x12\x03y\x085\n\r\n\x04\x04\x13\x03\0\x12\x05z\x08\x82\
    \x01\t\n\x0c\n\x05\x04\x13\x03\0\x01\x12\x03z\x10.\n\r\n\x06\x04\x13\x03\
    \0\x02\0\x12\x03{\x10]\n\x0e\n\x07\x04\x13\x03\0\x02\0\x04\x12\x03{\x10\
    \x18\n\x0e\n\x07\x04\x13\x03\0\x02\0\x06\x12\x03{\x19.\n\x0e\n\x07\x04\
    \x13\x03\0\x02\0\x01\x12\x03{/<\n\x0e\n\x07\x04\x13\x03\0\x02\0\x03\x12\
    \x03{?@\n\x0e\n\x07\x04\x13\x03\0\x02\0\x08\x12\x03{A\\\n\x0e\n\x07\x04\
    \x13\x03\0\x02\0\x07\x12\x03{L[\n\r\n\x06\x04\x13\x03\0\x02\x01\x12\x03|\
    \x10g\n\x0e\n\x07\x04\x13\x03\0\x02\x01\x04\x12\x03|\x10\x18\n\x0e\n\x07\
    \x04\x13\x03\0\x02\x01\x05\x12\x03|\x19\x1f\n\x0e\n\x07\x04\x13\x03\0\
    \x02\x01\x01\x12\x03|\x20+\n\x0e\n\x07\x04\x13\x03\0\x02\x01\x03\x12\x03\
    |./\n\x0e\n\x07\x04\x13\x03\0\x02\x01\x08\x12\x03|0f\n\x11\n\n\x04\x13\
    \x03\0\x02\x01\x08\xd0\x86\x03\x12\x03|1e\n\r\n\x06\x04\x13\x03\0\x02\
    \x02\x12\x03}\x10f\n\x0e\n\x07\x04\x13\x03\0\x02\x02\x04\x12\x03}\x10\
    \x18\n\x0e\n\x07\x04\x13\x03\0\x02\x02\x05\x12\x03}\x19\x1f\n\x0e\n\x07\
    \x04\x13\x03\0\x02\x02\x01\x12\x03}\x202\n\x0e\n\x07\x04\x13\x03\0\x02\
    \x02\x03\x12\x03}56\n\x0e\n\x07\x04\x13\x03\0\x02\x02\x08\x12\x03}7e\n\
    \x11\n\n\x04\x13\x03\0\x02\x02\x08\xd0\x86\x03\x12\x03}8d\n\r\n\x06\x04\
    \x13\x03\0\x02\x03\x12\x03~\x10\x7f\n\x0e\n\x07\x04\x13\x03\0\x02\x03\
    \x04\x12\x03~\x10\x18\n\x0e\n\x07\x04\x13\x03\0\x02\x03\x05\x12\x03~\x19\
    \x1f\n\x0e\n\x07\x04\x13\x03\0\x02\x03\x01\x12\x03~\x20,\n\x0e\n\x07\x04\
    \x13\x03\0\x02\x03\x03\x12\x03~/0\n\x0e\n\x07\x04\x13\x03\0\x02\x03\x08\
    \x12\x03~1~\n\x11\n\n\x04\x13\x03\0\x02\x03\x08\xd0\x86\x03\x12\x03~2}\n\
    \r\n\x06\x04\x13\x03\0\x02\x04\x12\x03\x7f\x10l\n\x0e\n\x07\x04\x13\x03\
    \0\x02\x04\x04\x12\x03\x7f\x10\x18\n\x0e\n\x07\x04\x13\x03\0\x02\x04\x05\
    \x12\x03\x7f\x19\x1f\n\x0e\n\x07\x04\x13\x03\0\x02\x04\x01\x12\x03\x7f\
    \x20,\n\x0e\n\x07\x04\x13\x03\0\x02\x04\x03\x12\x03\x7f/0\n\x0e\n\x07\
    \x04\x13\x03\0\x02\x04\x08\x12\x03\x7f1k\n\x11\n\n\x04\x13\x03\0\x02\x04\
    \x08\xd0\x86\x03\x12\x03\x7f2j\n\x0f\n\x06\x04\x13\x03\0\x02\x05\x12\x05\
    \x80\x01\x10\x97\x01\n\x0f\n\x07\x04\x13\x03\0\x02\x05\x04\x12\x04\x80\
    \x01\x10\x18\n\x0f\n\x07\x04\x13\x03\0\x02\x05\x05\x12\x04\x80\x01\x19\
    \x1f\n\x0f\n\x07\x04\x13\x03\0\x02\x05\x01\x12\x04\x80\x01\x203\n\x0f\n\
    \x07\x04\x13\x03\0\x02\x05\x03\x12\x04\x80\x0167\n\x10\n\x07\x04\x13\x03\
    \0\x02\x05\x08\x12\x05\x80\x018\x96\x01\n\x13\n\n\x04\x13\x03\0\x02\x05\
    \x08\xd0\x86\x03\x12\x05\x80\x019\x95\x01\n\x0f\n\x06\x04\x13\x03\0\x02\
    \x06\x12\x05\x81\x01\x10\xba\x01\n\x0f\n\x07\x04\x13\x03\0\x02\x06\x04\
    \x12\x04\x81\x01\x10\x18\n\x0f\n\x07\x04\x13\x03\0\x02\x06\x05\x12\x04\
    \x81\x01\x19\x1d\n\x0f\n\x07\x04\x13\x03\0\x02\x06\x01\x12\x04\x81\x01\
    \x1e&\n\x0f\n\x07\x04\x13\x03\0\x02\x06\x03\x12\x04\x81\x01)*\n\x10\n\
    \x07\x04\x13\x03\0\x02\x06\x08\x12\x05\x81\x01+\xb9\x01\n\x13\n\n\x04\
    \x13\x03\0\x02\x06\x08\xd0\x86\x03\x12\x05\x81\x01,\xb8\x01\n\x0c\n\x04\
    \x04\x13\x02\0\x12\x04\x84\x01\x08u\n\r\n\x05\x04\x13\x02\0\x04\x12\x04\
    \x84\x01\x08\x10\n\r\n\x05\x04\x13\x02\0\x06\x12\x04\x84\x01\x11^\n\r\n\
    \x05\x04\x13\x02\0\x01\x12\x04\x84\x01_p\n\r\n\x05\x04\x13\x02\0\x03\x12\
    \x04\x84\x01st\n\x0c\n\x02\x04\x14\x12\x06\x87\x01\0\x8c\x01\x01\n\x0b\n\
    \x03\x04\x14\x01\x12\x04\x87\x01\x086\n\x0c\n\x04\x04\x14\x02\0\x12\x04\
    \x88\x01\x08%\n\r\n\x05\x04\x14\x02\0\x04\x12\x04\x88\x01\x08\x10\n\r\n\
    \x05\x04\x14\x02\0\x05\x12\x04\x88\x01\x11\x18\n\r\n\x05\x04\x14\x02\0\
    \x01\x12\x04\x88\x01\x19\x20\n\r\n\x05\x04\x14\x02\0\x03\x12\x04\x88\x01\
    #$\n\x0c\n\x04\x04\x14\x02\x01\x12\x04\x89\x01\x08\"\n\r\n\x05\x04\x14\
    \x02\x01\x04\x12\x04\x89\x01\x08\x10\n\r\n\x05\x04\x14\x02\x01\x05\x12\
    \x04\x89\x01\x11\x17\n\r\n\x05\x04\x14\x02\x01\x01\x12\x04\x89\x01\x18\
    \x1d\n\r\n\x05\x04\x14\x02\x01\x03\x12\x04\x89\x01\x20!\n\x0c\n\x04\x04\
    \x14\x02\x02\x12\x04\x8a\x01\x08(\n\r\n\x05\x04\x14\x02\x02\x04\x12\x04\
    \x8a\x01\x08\x10\n\r\n\x05\x04\x14\x02\x02\x05\x12\x04\x8a\x01\x11\x17\n\
    \r\n\x05\x04\x14\x02\x02\x01\x12\x04\x8a\x01\x18#\n\r\n\x05\x04\x14\x02\
    \x02\x03\x12\x04\x8a\x01&'\n\x0c\n\x04\x04\x14\x02\x03\x12\x04\x8b\x01\
    \x08%\n\r\n\x05\x04\x14\x02\x03\x04\x12\x04\x8b\x01\x08\x10\n\r\n\x05\
    \x04\x14\x02\x03\x05\x12\x04\x8b\x01\x11\x17\n\r\n\x05\x04\x14\x02\x03\
    \x01\x12\x04\x8b\x01\x18\x20\n\r\n\x05\x04\x14\x02\x03\x03\x12\x04\x8b\
    \x01#$\n\x0c\n\x02\x04\x15\x12\x06\x8e\x01\0\x93\x01\x01\n\x0b\n\x03\x04\
    \x15\x01\x12\x04\x8e\x01\x08\x1d\n\x0c\n\x04\x04\x15\x02\0\x12\x04\x8f\
    \x01\x08%\n\r\n\x05\x04\x15\x02\0\x04\x12\x04\x8f\x01\x08\x10\n\r\n\x05\
    \x04\x15\x02\0\x05\x12\x04\x8f\x01\x11\x18\n\r\n\x05\x04\x15\x02\0\x01\
    \x12\x04\x8f\x01\x19\x20\n\r\n\x05\x04\x15\x02\0\x03\x12\x04\x8f\x01#$\n\
    \x0c\n\x04\x04\x15\x02\x01\x12\x04\x90\x01\x08(\n\r\n\x05\x04\x15\x02\
    \x01\x04\x12\x04\x90\x01\x08\x10\n\r\n\x05\x04\x15\x02\x01\x05\x12\x04\
    \x90\x01\x11\x16\n\r\n\x05\x04\x15\x02\x01\x01\x12\x04\x90\x01\x17#\n\r\
    \n\x05\x04\x15\x02\x01\x03\x12\x04\x90\x01&'\n\x0c\n\x04\x04\x15\x02\x02\
    \x12\x04\x91\x01\x08#\n\r\n\x05\x04\x15\x02\x02\x04\x12\x04\x91\x01\x08\
    \x10\n\r\n\x05\x04\x15\x02\x02\x05\x12\x04\x91\x01\x11\x17\n\r\n\x05\x04\
    \x15\x02\x02\x01\x12\x04\x91\x01\x18\x1e\n\r\n\x05\x04\x15\x02\x02\x03\
    \x12\x04\x91\x01!\"\n\x0c\n\x04\x04\x15\x02\x03\x12\x04\x92\x01\x08%\n\r\
    \n\x05\x04\x15\x02\x03\x04\x12\x04\x92\x01\x08\x10\n\r\n\x05\x04\x15\x02\
    \x03\x05\x12\x04\x92\x01\x11\x17\n\r\n\x05\x04\x15\x02\x03\x01\x12\x04\
    \x92\x01\x18\x20\n\r\n\x05\x04\x15\x02\x03\x03\x12\x04\x92\x01#$\n\x0c\n\
    \x02\x04\x16\x12\x06\x95\x01\0\x98\x01\x01\n\x0b\n\x03\x04\x16\x01\x12\
    \x04\x95\x01\x080\n\x0c\n\x04\x04\x16\x02\0\x12\x04\x96\x01\x08#\n\r\n\
    \x05\x04\x16\x02\0\x04\x12\x04\x96\x01\x08\x10\n\r\n\x05\x04\x16\x02\0\
    \x05\x12\x04\x96\x01\x11\x17\n\r\n\x05\x04\x16\x02\0\x01\x12\x04\x96\x01\
    \x18\x1e\n\r\n\x05\x04\x16\x02\0\x03\x12\x04\x96\x01!\"\n\x0c\n\x04\x04\
    \x16\x02\x01\x12\x04\x97\x01\x082\n\r\n\x05\x04\x16\x02\x01\x04\x12\x04\
    \x97\x01\x08\x10\n\r\n\x05\x04\x16\x02\x01\x06\x12\x04\x97\x01\x11'\n\r\
    \n\x05\x04\x16\x02\x01\x01\x12\x04\x97\x01(-\n\r\n\x05\x04\x16\x02\x01\
    \x03\x12\x04\x97\x0101\n\x0c\n\x02\x06\0\x12\x06\x9a\x01\0\xc0\x01\x01\n\
    \x0b\n\x03\x06\0\x01\x12\x04\x9a\x01\x08\x13\n\x0b\n\x03\x06\0\x03\x12\
    \x04\x9b\x01\x08S\n\x0e\n\x06\x06\0\x03\xd0\x86\x03\x12\x04\x9b\x01\x08S\
    \n\x0e\n\x04\x06\0\x02\0\x12\x06\x9d\x01\x08\x9f\x01\t\n\r\n\x05\x06\0\
    \x02\0\x01\x12\x04\x9d\x01\x0c/\n\r\n\x05\x06\0\x02\0\x02\x12\x04\x9d\
    \x011j\n\x0e\n\x05\x06\0\x02\0\x03\x12\x05\x9d\x01u\xaf\x01\n\r\n\x05\
    \x06\0\x02\0\x04\x12\x04\x9e\x01\x10o\n\x10\n\x08\x06\0\x02\0\x04\xd0\
    \x86\x03\x12\x04\x9e\x01\x10o\n\x0e\n\x04\x06\0\x02\x01\x12\x06\xa1\x01\
    \x08\xa3\x01\t\n\r\n\x05\x06\0\x02\x01\x01\x12\x04\xa1\x01\x0c\x20\n\r\n\
    \x05\x06\0\x02\x01\x02\x12\x04\xa1\x01\"L\n\x0e\n\x05\x06\0\x02\x01\x03\
    \x12\x05\xa1\x01W\x82\x01\n\r\n\x05\x06\0\x02\x01\x04\x12\x04\xa2\x01\
    \x10L\n\x10\n\x08\x06\0\x02\x01\x04\xd0\x86\x03\x12\x04\xa2\x01\x10L\n\
    \x0e\n\x04\x06\0\x02\x02\x12\x06\xa5\x01\x08\xa7\x01\t\n\r\n\x05\x06\0\
    \x02\x02\x01\x12\x04\xa5\x01\x0c\x1f\n\r\n\x05\x06\0\x02\x02\x02\x12\x04\
    \xa5\x01!J\n\r\n\x05\x06\0\x02\x02\x03\x12\x04\xa5\x01U\x7f\n\r\n\x05\
    \x06\0\x02\x02\x04\x12\x04\xa6\x01\x10R\n\x10\n\x08\x06\0\x02\x02\x04\
    \xd0\x86\x03\x12\x04\xa6\x01\x10R\n\x0e\n\x04\x06\0\x02\x03\x12\x06\xa9\
    \x01\x08\xab\x01\t\n\r\n\x05\x06\0\x02\x03\x01\x12\x04\xa9\x01\x0c#\n\r\
    \n\x05\x06\0\x02\x03\x02\x12\x04\xa9\x01%R\n\x0e\n\x05\x06\0\x02\x03\x03\
    \x12\x05\xa9\x01]\x8b\x01\n\r\n\x05\x06\0\x02\x03\x04\x12\x04\xaa\x01\
    \x10w\n\x10\n\x08\x06\0\x02\x03\x04\xd0\x86\x03\x12\x04\xaa\x01\x10w\n\
    \x0e\n\x04\x06\0\x02\x04\x12\x06\xad\x01\x08\xaf\x01\t\n\r\n\x05\x06\0\
    \x02\x04\x01\x12\x04\xad\x01\x0c!\n\r\n\x05\x06\0\x02\x04\x02\x12\x04\
    \xad\x01#N\n\x0e\n\x05\x06\0\x02\x04\x03\x12\x05\xad\x01Y\x85\x01\n\r\n\
    \x05\x06\0\x02\x04\x04\x12\x04\xae\x01\x10Z\n\x10\n\x08\x06\0\x02\x04\
    \x04\xd0\x86\x03\x12\x04\xae\x01\x10Z\n\x0e\n\x04\x06\0\x02\x05\x12\x06\
    \xb1\x01\x08\xb3\x01\t\n\r\n\x05\x06\0\x02\x05\x01\x12\x04\xb1\x01\x0c!\
    \n\r\n\x05\x06\0\x02\x05\x02\x12\x04\xb1\x01#N\n\x0e\n\x05\x06\0\x02\x05\
    \x03\x12\x05\xb1\x01Y\x85\x01\n\r\n\x05\x06\0\x02\x05\x04\x12\x04\xb2\
    \x01\x10T\n\x10\n\x08\x06\0\x02\x05\x04\xd0\x86\x03\x12\x04\xb2\x01\x10T\
    \n\x0e\n\x04\x06\0\x02\x06\x12\x06\xb5\x01\x08\xb7\x01\t\n\r\n\x05\x06\0\
    \x02\x06\x01\x12\x04\xb5\x01\x0c#\n\r\n\x05\x06\0\x02\x06\x02\x12\x04\
    \xb5\x01%R\n\x0e\n\x05\x06\0\x02\x06\x03\x12\x05\xb5\x01]\x8b\x01\n\r\n\
    \x05\x06\0\x02\x06\x04\x12\x04\xb6\x01\x10j\n\x10\n\x08\x06\0\x02\x06\
    \x04\xd0\x86\x03\x12\x04\xb6\x01\x10j\n\x0e\n\x04\x06\0\x02\x07\x12\x06\
    \xb9\x01\x08\xbb\x01\t\n\r\n\x05\x06\0\x02\x07\x01\x12\x04\xb9\x01\x0c#\
    \n\r\n\x05\x06\0\x02\x07\x02\x12\x04\xb9\x01%R\n\x0e\n\x05\x06\0\x02\x07\
    \x03\x12\x05\xb9\x01]\x8b\x01\n\r\n\x05\x06\0\x02\x07\x04\x12\x04\xba\
    \x01\x10U\n\x10\n\x08\x06\0\x02\x07\x04\xd0\x86\x03\x12\x04\xba\x01\x10U\
    \n\x0e\n\x04\x06\0\x02\x08\x12\x06\xbd\x01\x08\xbf\x01\t\n\r\n\x05\x06\0\
    \x02\x08\x01\x12\x04\xbd\x01\x0c\x1e\n\r\n\x05\x06\0\x02\x08\x02\x12\x04\
    \xbd\x01\x20H\n\r\n\x05\x06\0\x02\x08\x03\x12\x04\xbd\x01S|\n\r\n\x05\
    \x06\0\x02\x08\x04\x12\x04\xbe\x01\x10Z\n\x10\n\x08\x06\0\x02\x08\x04\
    \xd0\x86\x03\x12\x04\xbe\x01\x10Z\n\x0c\n\x02\x06\x01\x12\x06\xc2\x01\0\
    \xc8\x01\x01\n\x0b\n\x03\x06\x01\x01\x12\x04\xc2\x01\x08\x16\n\x0b\n\x03\
    \x06\x01\x03\x12\x04\xc3\x01\x08[\n\x0e\n\x06\x06\x01\x03\xd0\x86\x03\
    \x12\x04\xc3\x01\x08[\n\x0e\n\x04\x06\x01\x02\0\x12\x06\xc5\x01\x08\xc7\
    \x01\t\n\r\n\x05\x06\x01\x02\0\x01\x12\x04\xc5\x01\x0c\x20\n\r\n\x05\x06\
    \x01\x02\0\x02\x12\x04\xc5\x01\"O\n\x0e\n\x05\x06\x01\x02\0\x03\x12\x05\
    \xc5\x01Z\x88\x01\n\x0e\n\x05\x06\x01\x02\0\x04\x12\x05\xc6\x01\x10\x89\
    \x01\n\x11\n\x08\x06\x01\x02\0\x04\xd0\x86\x03\x12\x05\xc6\x01\x10\x89\
    \x01\n\x0c\n\x02\x06\x02\x12\x06\xca\x01\0\xd0\x01\x01\n\x0b\n\x03\x06\
    \x02\x01\x12\x04\xca\x01\x08\x16\n\x0b\n\x03\x06\x02\x03\x12\x04\xcb\x01\
    \x08t\n\x0e\n\x06\x06\x02\x03\xd0\x86\x03\x12\x04\xcb\x01\x08t\n\x0e\n\
    \x04\x06\x02\x02\0\x12\x06\xcd\x01\x08\xcf\x01\t\n\r\n\x05\x06\x02\x02\0\
    \x01\x12\x04\xcd\x01\x0c\"\n\r\n\x05\x06\x02\x02\0\x02\x12\x04\xcd\x01$S\
    \n\x0e\n\x05\x06\x02\x02\0\x03\x12\x05\xcd\x01^\x87\x01\n\r\n\x05\x06\
    \x02\x02\0\x04\x12\x04\xce\x01\x10x\n\x10\n\x08\x06\x02\x02\0\x04\xd0\
    \x86\x03\x12\x04\xce\x01\x10x\
";

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

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

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