steam-protobuf 0.1.2

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CMsgSteamDatagramRelayAuthTicket {
    // message fields
    time_expiry: ::std::option::Option<u32>,
    authorized_client_identity_string: ::protobuf::SingularField<::std::string::String>,
    gameserver_identity_string: ::protobuf::SingularField<::std::string::String>,
    authorized_public_ip: ::std::option::Option<u32>,
    gameserver_address: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    app_id: ::std::option::Option<u32>,
    virtual_port: ::std::option::Option<u32>,
    pub extra_fields: ::protobuf::RepeatedField<CMsgSteamDatagramRelayAuthTicket_ExtraField>,
    legacy_authorized_steam_id: ::std::option::Option<u64>,
    legacy_gameserver_steam_id: ::std::option::Option<u64>,
    legacy_gameserver_net_id: ::std::option::Option<u64>,
    legacy_gameserver_pop_id: ::std::option::Option<u32>,
    legacy_authorized_client_identity_binary: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    legacy_gameserver_identity_binary: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed32 time_expiry = 1;


    pub fn get_time_expiry(&self) -> u32 {
        self.time_expiry.unwrap_or(0)
    }
    pub fn clear_time_expiry(&mut self) {
        self.time_expiry = ::std::option::Option::None;
    }

    pub fn has_time_expiry(&self) -> bool {
        self.time_expiry.is_some()
    }

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

    // optional string authorized_client_identity_string = 14;


    pub fn get_authorized_client_identity_string(&self) -> &str {
        match self.authorized_client_identity_string.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_authorized_client_identity_string(&mut self) {
        self.authorized_client_identity_string.clear();
    }

    pub fn has_authorized_client_identity_string(&self) -> bool {
        self.authorized_client_identity_string.is_some()
    }

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

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

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

    // optional string gameserver_identity_string = 15;


    pub fn get_gameserver_identity_string(&self) -> &str {
        match self.gameserver_identity_string.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_gameserver_identity_string(&mut self) {
        self.gameserver_identity_string.clear();
    }

    pub fn has_gameserver_identity_string(&self) -> bool {
        self.gameserver_identity_string.is_some()
    }

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

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

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

    // optional fixed32 authorized_public_ip = 3;


    pub fn get_authorized_public_ip(&self) -> u32 {
        self.authorized_public_ip.unwrap_or(0)
    }
    pub fn clear_authorized_public_ip(&mut self) {
        self.authorized_public_ip = ::std::option::Option::None;
    }

    pub fn has_authorized_public_ip(&self) -> bool {
        self.authorized_public_ip.is_some()
    }

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

    // optional bytes gameserver_address = 11;


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

    pub fn has_gameserver_address(&self) -> bool {
        self.gameserver_address.is_some()
    }

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

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

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

    // optional uint32 app_id = 7;


    pub fn get_app_id(&self) -> u32 {
        self.app_id.unwrap_or(0)
    }
    pub fn clear_app_id(&mut self) {
        self.app_id = ::std::option::Option::None;
    }

    pub fn has_app_id(&self) -> bool {
        self.app_id.is_some()
    }

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

    // optional uint32 virtual_port = 10;


    pub fn get_virtual_port(&self) -> u32 {
        self.virtual_port.unwrap_or(0)
    }
    pub fn clear_virtual_port(&mut self) {
        self.virtual_port = ::std::option::Option::None;
    }

    pub fn has_virtual_port(&self) -> bool {
        self.virtual_port.is_some()
    }

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

    // repeated .CMsgSteamDatagramRelayAuthTicket.ExtraField extra_fields = 8;


    pub fn get_extra_fields(&self) -> &[CMsgSteamDatagramRelayAuthTicket_ExtraField] {
        &self.extra_fields
    }
    pub fn clear_extra_fields(&mut self) {
        self.extra_fields.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_extra_fields(&mut self) -> &mut ::protobuf::RepeatedField<CMsgSteamDatagramRelayAuthTicket_ExtraField> {
        &mut self.extra_fields
    }

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

    // optional fixed64 legacy_authorized_steam_id = 2;


    pub fn get_legacy_authorized_steam_id(&self) -> u64 {
        self.legacy_authorized_steam_id.unwrap_or(0)
    }
    pub fn clear_legacy_authorized_steam_id(&mut self) {
        self.legacy_authorized_steam_id = ::std::option::Option::None;
    }

    pub fn has_legacy_authorized_steam_id(&self) -> bool {
        self.legacy_authorized_steam_id.is_some()
    }

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

    // optional fixed64 legacy_gameserver_steam_id = 4;


    pub fn get_legacy_gameserver_steam_id(&self) -> u64 {
        self.legacy_gameserver_steam_id.unwrap_or(0)
    }
    pub fn clear_legacy_gameserver_steam_id(&mut self) {
        self.legacy_gameserver_steam_id = ::std::option::Option::None;
    }

    pub fn has_legacy_gameserver_steam_id(&self) -> bool {
        self.legacy_gameserver_steam_id.is_some()
    }

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

    // optional fixed64 legacy_gameserver_net_id = 5;


    pub fn get_legacy_gameserver_net_id(&self) -> u64 {
        self.legacy_gameserver_net_id.unwrap_or(0)
    }
    pub fn clear_legacy_gameserver_net_id(&mut self) {
        self.legacy_gameserver_net_id = ::std::option::Option::None;
    }

    pub fn has_legacy_gameserver_net_id(&self) -> bool {
        self.legacy_gameserver_net_id.is_some()
    }

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

    // optional fixed32 legacy_gameserver_pop_id = 9;


    pub fn get_legacy_gameserver_pop_id(&self) -> u32 {
        self.legacy_gameserver_pop_id.unwrap_or(0)
    }
    pub fn clear_legacy_gameserver_pop_id(&mut self) {
        self.legacy_gameserver_pop_id = ::std::option::Option::None;
    }

    pub fn has_legacy_gameserver_pop_id(&self) -> bool {
        self.legacy_gameserver_pop_id.is_some()
    }

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

    // optional bytes legacy_authorized_client_identity_binary = 12;


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

    pub fn has_legacy_authorized_client_identity_binary(&self) -> bool {
        self.legacy_authorized_client_identity_binary.is_some()
    }

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

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

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

    // optional bytes legacy_gameserver_identity_binary = 13;


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

    pub fn has_legacy_gameserver_identity_binary(&self) -> bool {
        self.legacy_gameserver_identity_binary.is_some()
    }

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

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

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

impl ::protobuf::Message for CMsgSteamDatagramRelayAuthTicket {
    fn is_initialized(&self) -> bool {
        for v in &self.extra_fields {
            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::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.time_expiry = ::std::option::Option::Some(tmp);
                },
                14 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.authorized_client_identity_string)?;
                },
                15 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.gameserver_identity_string)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.authorized_public_ip = ::std::option::Option::Some(tmp);
                },
                11 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.gameserver_address)?;
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.app_id = ::std::option::Option::Some(tmp);
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.virtual_port = ::std::option::Option::Some(tmp);
                },
                8 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.extra_fields)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.legacy_authorized_steam_id = ::std::option::Option::Some(tmp);
                },
                4 => {
                    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.legacy_gameserver_steam_id = ::std::option::Option::Some(tmp);
                },
                5 => {
                    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.legacy_gameserver_net_id = ::std::option::Option::Some(tmp);
                },
                9 => {
                    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.legacy_gameserver_pop_id = ::std::option::Option::Some(tmp);
                },
                12 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.legacy_authorized_client_identity_binary)?;
                },
                13 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.legacy_gameserver_identity_binary)?;
                },
                _ => {
                    ::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.time_expiry {
            my_size += 5;
        }
        if let Some(ref v) = self.authorized_client_identity_string.as_ref() {
            my_size += ::protobuf::rt::string_size(14, &v);
        }
        if let Some(ref v) = self.gameserver_identity_string.as_ref() {
            my_size += ::protobuf::rt::string_size(15, &v);
        }
        if let Some(v) = self.authorized_public_ip {
            my_size += 5;
        }
        if let Some(ref v) = self.gameserver_address.as_ref() {
            my_size += ::protobuf::rt::bytes_size(11, &v);
        }
        if let Some(v) = self.app_id {
            my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.virtual_port {
            my_size += ::protobuf::rt::value_size(10, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.extra_fields {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(v) = self.legacy_authorized_steam_id {
            my_size += 9;
        }
        if let Some(v) = self.legacy_gameserver_steam_id {
            my_size += 9;
        }
        if let Some(v) = self.legacy_gameserver_net_id {
            my_size += 9;
        }
        if let Some(v) = self.legacy_gameserver_pop_id {
            my_size += 5;
        }
        if let Some(ref v) = self.legacy_authorized_client_identity_binary.as_ref() {
            my_size += ::protobuf::rt::bytes_size(12, &v);
        }
        if let Some(ref v) = self.legacy_gameserver_identity_binary.as_ref() {
            my_size += ::protobuf::rt::bytes_size(13, &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.time_expiry {
            os.write_fixed32(1, v)?;
        }
        if let Some(ref v) = self.authorized_client_identity_string.as_ref() {
            os.write_string(14, &v)?;
        }
        if let Some(ref v) = self.gameserver_identity_string.as_ref() {
            os.write_string(15, &v)?;
        }
        if let Some(v) = self.authorized_public_ip {
            os.write_fixed32(3, v)?;
        }
        if let Some(ref v) = self.gameserver_address.as_ref() {
            os.write_bytes(11, &v)?;
        }
        if let Some(v) = self.app_id {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.virtual_port {
            os.write_uint32(10, v)?;
        }
        for v in &self.extra_fields {
            os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(v) = self.legacy_authorized_steam_id {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.legacy_gameserver_steam_id {
            os.write_fixed64(4, v)?;
        }
        if let Some(v) = self.legacy_gameserver_net_id {
            os.write_fixed64(5, v)?;
        }
        if let Some(v) = self.legacy_gameserver_pop_id {
            os.write_fixed32(9, v)?;
        }
        if let Some(ref v) = self.legacy_authorized_client_identity_binary.as_ref() {
            os.write_bytes(12, &v)?;
        }
        if let Some(ref v) = self.legacy_gameserver_identity_binary.as_ref() {
            os.write_bytes(13, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "time_expiry",
                |m: &CMsgSteamDatagramRelayAuthTicket| { &m.time_expiry },
                |m: &mut CMsgSteamDatagramRelayAuthTicket| { &mut m.time_expiry },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "authorized_client_identity_string",
                |m: &CMsgSteamDatagramRelayAuthTicket| { &m.authorized_client_identity_string },
                |m: &mut CMsgSteamDatagramRelayAuthTicket| { &mut m.authorized_client_identity_string },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "gameserver_identity_string",
                |m: &CMsgSteamDatagramRelayAuthTicket| { &m.gameserver_identity_string },
                |m: &mut CMsgSteamDatagramRelayAuthTicket| { &mut m.gameserver_identity_string },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "authorized_public_ip",
                |m: &CMsgSteamDatagramRelayAuthTicket| { &m.authorized_public_ip },
                |m: &mut CMsgSteamDatagramRelayAuthTicket| { &mut m.authorized_public_ip },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "gameserver_address",
                |m: &CMsgSteamDatagramRelayAuthTicket| { &m.gameserver_address },
                |m: &mut CMsgSteamDatagramRelayAuthTicket| { &mut m.gameserver_address },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "app_id",
                |m: &CMsgSteamDatagramRelayAuthTicket| { &m.app_id },
                |m: &mut CMsgSteamDatagramRelayAuthTicket| { &mut m.app_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "virtual_port",
                |m: &CMsgSteamDatagramRelayAuthTicket| { &m.virtual_port },
                |m: &mut CMsgSteamDatagramRelayAuthTicket| { &mut m.virtual_port },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CMsgSteamDatagramRelayAuthTicket_ExtraField>>(
                "extra_fields",
                |m: &CMsgSteamDatagramRelayAuthTicket| { &m.extra_fields },
                |m: &mut CMsgSteamDatagramRelayAuthTicket| { &mut m.extra_fields },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "legacy_authorized_steam_id",
                |m: &CMsgSteamDatagramRelayAuthTicket| { &m.legacy_authorized_steam_id },
                |m: &mut CMsgSteamDatagramRelayAuthTicket| { &mut m.legacy_authorized_steam_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "legacy_gameserver_steam_id",
                |m: &CMsgSteamDatagramRelayAuthTicket| { &m.legacy_gameserver_steam_id },
                |m: &mut CMsgSteamDatagramRelayAuthTicket| { &mut m.legacy_gameserver_steam_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "legacy_gameserver_net_id",
                |m: &CMsgSteamDatagramRelayAuthTicket| { &m.legacy_gameserver_net_id },
                |m: &mut CMsgSteamDatagramRelayAuthTicket| { &mut m.legacy_gameserver_net_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "legacy_gameserver_pop_id",
                |m: &CMsgSteamDatagramRelayAuthTicket| { &m.legacy_gameserver_pop_id },
                |m: &mut CMsgSteamDatagramRelayAuthTicket| { &mut m.legacy_gameserver_pop_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "legacy_authorized_client_identity_binary",
                |m: &CMsgSteamDatagramRelayAuthTicket| { &m.legacy_authorized_client_identity_binary },
                |m: &mut CMsgSteamDatagramRelayAuthTicket| { &mut m.legacy_authorized_client_identity_binary },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "legacy_gameserver_identity_binary",
                |m: &CMsgSteamDatagramRelayAuthTicket| { &m.legacy_gameserver_identity_binary },
                |m: &mut CMsgSteamDatagramRelayAuthTicket| { &mut m.legacy_gameserver_identity_binary },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgSteamDatagramRelayAuthTicket>(
                "CMsgSteamDatagramRelayAuthTicket",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgSteamDatagramRelayAuthTicket {
    fn clear(&mut self) {
        self.time_expiry = ::std::option::Option::None;
        self.authorized_client_identity_string.clear();
        self.gameserver_identity_string.clear();
        self.authorized_public_ip = ::std::option::Option::None;
        self.gameserver_address.clear();
        self.app_id = ::std::option::Option::None;
        self.virtual_port = ::std::option::Option::None;
        self.extra_fields.clear();
        self.legacy_authorized_steam_id = ::std::option::Option::None;
        self.legacy_gameserver_steam_id = ::std::option::Option::None;
        self.legacy_gameserver_net_id = ::std::option::Option::None;
        self.legacy_gameserver_pop_id = ::std::option::Option::None;
        self.legacy_authorized_client_identity_binary.clear();
        self.legacy_gameserver_identity_binary.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CMsgSteamDatagramRelayAuthTicket_ExtraField {
    // message fields
    name: ::protobuf::SingularField<::std::string::String>,
    string_value: ::protobuf::SingularField<::std::string::String>,
    int64_value: ::std::option::Option<i64>,
    fixed64_value: ::std::option::Option<u64>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string name = 1;


    pub fn get_name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    pub fn has_name(&self) -> bool {
        self.name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.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_name(&mut self) -> &mut ::std::string::String {
        if self.name.is_none() {
            self.name.set_default();
        }
        self.name.as_mut().unwrap()
    }

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

    // optional string string_value = 2;


    pub fn get_string_value(&self) -> &str {
        match self.string_value.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_string_value(&mut self) {
        self.string_value.clear();
    }

    pub fn has_string_value(&self) -> bool {
        self.string_value.is_some()
    }

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

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

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

    // optional sint64 int64_value = 3;


    pub fn get_int64_value(&self) -> i64 {
        self.int64_value.unwrap_or(0)
    }
    pub fn clear_int64_value(&mut self) {
        self.int64_value = ::std::option::Option::None;
    }

    pub fn has_int64_value(&self) -> bool {
        self.int64_value.is_some()
    }

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

    // optional fixed64 fixed64_value = 5;


    pub fn get_fixed64_value(&self) -> u64 {
        self.fixed64_value.unwrap_or(0)
    }
    pub fn clear_fixed64_value(&mut self) {
        self.fixed64_value = ::std::option::Option::None;
    }

    pub fn has_fixed64_value(&self) -> bool {
        self.fixed64_value.is_some()
    }

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

impl ::protobuf::Message for CMsgSteamDatagramRelayAuthTicket_ExtraField {
    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.name)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.string_value)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_sint64()?;
                    self.int64_value = ::std::option::Option::Some(tmp);
                },
                5 => {
                    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.fixed64_value = ::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.name.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.string_value.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.int64_value {
            my_size += ::protobuf::rt::value_varint_zigzag_size(3, v);
        }
        if let Some(v) = self.fixed64_value {
            my_size += 9;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.name.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.string_value.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.int64_value {
            os.write_sint64(3, v)?;
        }
        if let Some(v) = self.fixed64_value {
            os.write_fixed64(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() -> CMsgSteamDatagramRelayAuthTicket_ExtraField {
        CMsgSteamDatagramRelayAuthTicket_ExtraField::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>(
                "name",
                |m: &CMsgSteamDatagramRelayAuthTicket_ExtraField| { &m.name },
                |m: &mut CMsgSteamDatagramRelayAuthTicket_ExtraField| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "string_value",
                |m: &CMsgSteamDatagramRelayAuthTicket_ExtraField| { &m.string_value },
                |m: &mut CMsgSteamDatagramRelayAuthTicket_ExtraField| { &mut m.string_value },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeSint64>(
                "int64_value",
                |m: &CMsgSteamDatagramRelayAuthTicket_ExtraField| { &m.int64_value },
                |m: &mut CMsgSteamDatagramRelayAuthTicket_ExtraField| { &mut m.int64_value },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "fixed64_value",
                |m: &CMsgSteamDatagramRelayAuthTicket_ExtraField| { &m.fixed64_value },
                |m: &mut CMsgSteamDatagramRelayAuthTicket_ExtraField| { &mut m.fixed64_value },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgSteamDatagramRelayAuthTicket_ExtraField>(
                "CMsgSteamDatagramRelayAuthTicket.ExtraField",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgSteamDatagramRelayAuthTicket_ExtraField {
    fn clear(&mut self) {
        self.name.clear();
        self.string_value.clear();
        self.int64_value = ::std::option::Option::None;
        self.fixed64_value = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CMsgSteamDatagramSignedRelayAuthTicket {
    // message fields
    reserved_do_not_use: ::std::option::Option<u64>,
    key_id: ::std::option::Option<u64>,
    ticket: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    signature: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 reserved_do_not_use = 1;


    pub fn get_reserved_do_not_use(&self) -> u64 {
        self.reserved_do_not_use.unwrap_or(0)
    }
    pub fn clear_reserved_do_not_use(&mut self) {
        self.reserved_do_not_use = ::std::option::Option::None;
    }

    pub fn has_reserved_do_not_use(&self) -> bool {
        self.reserved_do_not_use.is_some()
    }

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

    // optional fixed64 key_id = 2;


    pub fn get_key_id(&self) -> u64 {
        self.key_id.unwrap_or(0)
    }
    pub fn clear_key_id(&mut self) {
        self.key_id = ::std::option::Option::None;
    }

    pub fn has_key_id(&self) -> bool {
        self.key_id.is_some()
    }

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

    // optional bytes ticket = 3;


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

    pub fn has_ticket(&self) -> bool {
        self.ticket.is_some()
    }

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

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

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

    // optional bytes signature = 4;


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

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

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

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

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

impl ::protobuf::Message for CMsgSteamDatagramSignedRelayAuthTicket {
    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.reserved_do_not_use = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.key_id = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.ticket)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.signature)?;
                },
                _ => {
                    ::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.reserved_do_not_use {
            my_size += 9;
        }
        if let Some(v) = self.key_id {
            my_size += 9;
        }
        if let Some(ref v) = self.ticket.as_ref() {
            my_size += ::protobuf::rt::bytes_size(3, &v);
        }
        if let Some(ref v) = self.signature.as_ref() {
            my_size += ::protobuf::rt::bytes_size(4, &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.reserved_do_not_use {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.key_id {
            os.write_fixed64(2, v)?;
        }
        if let Some(ref v) = self.ticket.as_ref() {
            os.write_bytes(3, &v)?;
        }
        if let Some(ref v) = self.signature.as_ref() {
            os.write_bytes(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() -> CMsgSteamDatagramSignedRelayAuthTicket {
        CMsgSteamDatagramSignedRelayAuthTicket::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>(
                "reserved_do_not_use",
                |m: &CMsgSteamDatagramSignedRelayAuthTicket| { &m.reserved_do_not_use },
                |m: &mut CMsgSteamDatagramSignedRelayAuthTicket| { &mut m.reserved_do_not_use },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "key_id",
                |m: &CMsgSteamDatagramSignedRelayAuthTicket| { &m.key_id },
                |m: &mut CMsgSteamDatagramSignedRelayAuthTicket| { &mut m.key_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "ticket",
                |m: &CMsgSteamDatagramSignedRelayAuthTicket| { &m.ticket },
                |m: &mut CMsgSteamDatagramSignedRelayAuthTicket| { &mut m.ticket },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "signature",
                |m: &CMsgSteamDatagramSignedRelayAuthTicket| { &m.signature },
                |m: &mut CMsgSteamDatagramSignedRelayAuthTicket| { &mut m.signature },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgSteamDatagramSignedRelayAuthTicket>(
                "CMsgSteamDatagramSignedRelayAuthTicket",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgSteamDatagramSignedRelayAuthTicket {
    fn clear(&mut self) {
        self.reserved_do_not_use = ::std::option::Option::None;
        self.key_id = ::std::option::Option::None;
        self.ticket.clear();
        self.signature.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CMsgSteamDatagramCachedCredentialsForApp {
    // message fields
    private_key: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    cert: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    pub relay_tickets: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bytes private_key = 1;


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

    pub fn has_private_key(&self) -> bool {
        self.private_key.is_some()
    }

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

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

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

    // optional bytes cert = 2;


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

    pub fn has_cert(&self) -> bool {
        self.cert.is_some()
    }

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

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

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

    // repeated bytes relay_tickets = 3;


    pub fn get_relay_tickets(&self) -> &[::std::vec::Vec<u8>] {
        &self.relay_tickets
    }
    pub fn clear_relay_tickets(&mut self) {
        self.relay_tickets.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_relay_tickets(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
        &mut self.relay_tickets
    }

    // Take field
    pub fn take_relay_tickets(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
        ::std::mem::replace(&mut self.relay_tickets, ::protobuf::RepeatedField::new())
    }
}

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.private_key)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.cert)?;
                },
                3 => {
                    ::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.relay_tickets)?;
                },
                _ => {
                    ::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.private_key.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(ref v) = self.cert.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        for value in &self.relay_tickets {
            my_size += ::protobuf::rt::bytes_size(3, &value);
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.private_key.as_ref() {
            os.write_bytes(1, &v)?;
        }
        if let Some(ref v) = self.cert.as_ref() {
            os.write_bytes(2, &v)?;
        }
        for v in &self.relay_tickets {
            os.write_bytes(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() -> CMsgSteamDatagramCachedCredentialsForApp {
        CMsgSteamDatagramCachedCredentialsForApp::new()
    }

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

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

impl ::protobuf::Clear for CMsgSteamDatagramCachedCredentialsForApp {
    fn clear(&mut self) {
        self.private_key.clear();
        self.cert.clear();
        self.relay_tickets.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CMsgSteamDatagramGameCoordinatorServerLogin {
    // message fields
    time_generated: ::std::option::Option<u32>,
    appid: ::std::option::Option<u32>,
    routing: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    appdata: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    legacy_identity_binary: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    identity_string: ::protobuf::SingularField<::std::string::String>,
    dummy_steam_id: ::std::option::Option<u64>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 time_generated = 1;


    pub fn get_time_generated(&self) -> u32 {
        self.time_generated.unwrap_or(0)
    }
    pub fn clear_time_generated(&mut self) {
        self.time_generated = ::std::option::Option::None;
    }

    pub fn has_time_generated(&self) -> bool {
        self.time_generated.is_some()
    }

    // Param is passed by value, moved
    pub fn set_time_generated(&mut self, v: u32) {
        self.time_generated = ::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 bytes routing = 3;


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

    pub fn has_routing(&self) -> bool {
        self.routing.is_some()
    }

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

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

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

    // optional bytes appdata = 4;


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

    pub fn has_appdata(&self) -> bool {
        self.appdata.is_some()
    }

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

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

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

    // optional bytes legacy_identity_binary = 5;


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

    pub fn has_legacy_identity_binary(&self) -> bool {
        self.legacy_identity_binary.is_some()
    }

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

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

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

    // optional string identity_string = 6;


    pub fn get_identity_string(&self) -> &str {
        match self.identity_string.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_identity_string(&mut self) {
        self.identity_string.clear();
    }

    pub fn has_identity_string(&self) -> bool {
        self.identity_string.is_some()
    }

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

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

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

    // optional fixed64 dummy_steam_id = 99;


    pub fn get_dummy_steam_id(&self) -> u64 {
        self.dummy_steam_id.unwrap_or(0)
    }
    pub fn clear_dummy_steam_id(&mut self) {
        self.dummy_steam_id = ::std::option::Option::None;
    }

    pub fn has_dummy_steam_id(&self) -> bool {
        self.dummy_steam_id.is_some()
    }

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

impl ::protobuf::Message for CMsgSteamDatagramGameCoordinatorServerLogin {
    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.time_generated = ::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_bytes_into(wire_type, is, &mut self.routing)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.appdata)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.legacy_identity_binary)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.identity_string)?;
                },
                99 => {
                    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.dummy_steam_id = ::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.time_generated {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.appid {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.routing.as_ref() {
            my_size += ::protobuf::rt::bytes_size(3, &v);
        }
        if let Some(ref v) = self.appdata.as_ref() {
            my_size += ::protobuf::rt::bytes_size(4, &v);
        }
        if let Some(ref v) = self.legacy_identity_binary.as_ref() {
            my_size += ::protobuf::rt::bytes_size(5, &v);
        }
        if let Some(ref v) = self.identity_string.as_ref() {
            my_size += ::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.dummy_steam_id {
            my_size += 10;
        }
        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.time_generated {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(2, v)?;
        }
        if let Some(ref v) = self.routing.as_ref() {
            os.write_bytes(3, &v)?;
        }
        if let Some(ref v) = self.appdata.as_ref() {
            os.write_bytes(4, &v)?;
        }
        if let Some(ref v) = self.legacy_identity_binary.as_ref() {
            os.write_bytes(5, &v)?;
        }
        if let Some(ref v) = self.identity_string.as_ref() {
            os.write_string(6, &v)?;
        }
        if let Some(v) = self.dummy_steam_id {
            os.write_fixed64(99, 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() -> CMsgSteamDatagramGameCoordinatorServerLogin {
        CMsgSteamDatagramGameCoordinatorServerLogin::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>(
                "time_generated",
                |m: &CMsgSteamDatagramGameCoordinatorServerLogin| { &m.time_generated },
                |m: &mut CMsgSteamDatagramGameCoordinatorServerLogin| { &mut m.time_generated },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "appid",
                |m: &CMsgSteamDatagramGameCoordinatorServerLogin| { &m.appid },
                |m: &mut CMsgSteamDatagramGameCoordinatorServerLogin| { &mut m.appid },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "routing",
                |m: &CMsgSteamDatagramGameCoordinatorServerLogin| { &m.routing },
                |m: &mut CMsgSteamDatagramGameCoordinatorServerLogin| { &mut m.routing },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "appdata",
                |m: &CMsgSteamDatagramGameCoordinatorServerLogin| { &m.appdata },
                |m: &mut CMsgSteamDatagramGameCoordinatorServerLogin| { &mut m.appdata },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "legacy_identity_binary",
                |m: &CMsgSteamDatagramGameCoordinatorServerLogin| { &m.legacy_identity_binary },
                |m: &mut CMsgSteamDatagramGameCoordinatorServerLogin| { &mut m.legacy_identity_binary },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "identity_string",
                |m: &CMsgSteamDatagramGameCoordinatorServerLogin| { &m.identity_string },
                |m: &mut CMsgSteamDatagramGameCoordinatorServerLogin| { &mut m.identity_string },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "dummy_steam_id",
                |m: &CMsgSteamDatagramGameCoordinatorServerLogin| { &m.dummy_steam_id },
                |m: &mut CMsgSteamDatagramGameCoordinatorServerLogin| { &mut m.dummy_steam_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgSteamDatagramGameCoordinatorServerLogin>(
                "CMsgSteamDatagramGameCoordinatorServerLogin",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgSteamDatagramGameCoordinatorServerLogin {
    fn clear(&mut self) {
        self.time_generated = ::std::option::Option::None;
        self.appid = ::std::option::Option::None;
        self.routing.clear();
        self.appdata.clear();
        self.legacy_identity_binary.clear();
        self.identity_string.clear();
        self.dummy_steam_id = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CMsgSteamDatagramSignedGameCoordinatorServerLogin {
    // message fields
    pub cert: ::protobuf::SingularPtrField<super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned>,
    login: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    signature: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional .CMsgSteamDatagramCertificateSigned cert = 1;


    pub fn get_cert(&self) -> &super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned {
        self.cert.as_ref().unwrap_or_else(|| <super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned as ::protobuf::Message>::default_instance())
    }
    pub fn clear_cert(&mut self) {
        self.cert.clear();
    }

    pub fn has_cert(&self) -> bool {
        self.cert.is_some()
    }

    // Param is passed by value, moved
    pub fn set_cert(&mut self, v: super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned) {
        self.cert = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_cert(&mut self) -> &mut super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned {
        if self.cert.is_none() {
            self.cert.set_default();
        }
        self.cert.as_mut().unwrap()
    }

    // Take field
    pub fn take_cert(&mut self) -> super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned {
        self.cert.take().unwrap_or_else(|| super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned::new())
    }

    // optional bytes login = 2;


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

    pub fn has_login(&self) -> bool {
        self.login.is_some()
    }

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

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

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

    // optional bytes signature = 3;


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

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

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

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

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

impl ::protobuf::Message for CMsgSteamDatagramSignedGameCoordinatorServerLogin {
    fn is_initialized(&self) -> bool {
        for v in &self.cert {
            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_singular_message_into(wire_type, is, &mut self.cert)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.login)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.signature)?;
                },
                _ => {
                    ::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.cert.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.login.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(ref v) = self.signature.as_ref() {
            my_size += ::protobuf::rt::bytes_size(3, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.cert.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.login.as_ref() {
            os.write_bytes(2, &v)?;
        }
        if let Some(ref v) = self.signature.as_ref() {
            os.write_bytes(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() -> CMsgSteamDatagramSignedGameCoordinatorServerLogin {
        CMsgSteamDatagramSignedGameCoordinatorServerLogin::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_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned>>(
                "cert",
                |m: &CMsgSteamDatagramSignedGameCoordinatorServerLogin| { &m.cert },
                |m: &mut CMsgSteamDatagramSignedGameCoordinatorServerLogin| { &mut m.cert },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "login",
                |m: &CMsgSteamDatagramSignedGameCoordinatorServerLogin| { &m.login },
                |m: &mut CMsgSteamDatagramSignedGameCoordinatorServerLogin| { &mut m.login },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "signature",
                |m: &CMsgSteamDatagramSignedGameCoordinatorServerLogin| { &m.signature },
                |m: &mut CMsgSteamDatagramSignedGameCoordinatorServerLogin| { &mut m.signature },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgSteamDatagramSignedGameCoordinatorServerLogin>(
                "CMsgSteamDatagramSignedGameCoordinatorServerLogin",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgSteamDatagramSignedGameCoordinatorServerLogin {
    fn clear(&mut self) {
        self.cert.clear();
        self.login.clear();
        self.signature.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CMsgSteamDatagramHostedServerAddressPlaintext {
    // message fields
    ipv4: ::std::option::Option<u32>,
    ipv6: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    port: ::std::option::Option<u32>,
    routing_secret: ::std::option::Option<u64>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed32 ipv4 = 1;


    pub fn get_ipv4(&self) -> u32 {
        self.ipv4.unwrap_or(0)
    }
    pub fn clear_ipv4(&mut self) {
        self.ipv4 = ::std::option::Option::None;
    }

    pub fn has_ipv4(&self) -> bool {
        self.ipv4.is_some()
    }

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

    // optional bytes ipv6 = 2;


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

    pub fn has_ipv6(&self) -> bool {
        self.ipv6.is_some()
    }

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

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

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

    // optional uint32 port = 3;


    pub fn get_port(&self) -> u32 {
        self.port.unwrap_or(0)
    }
    pub fn clear_port(&mut self) {
        self.port = ::std::option::Option::None;
    }

    pub fn has_port(&self) -> bool {
        self.port.is_some()
    }

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

    // optional fixed64 routing_secret = 4;


    pub fn get_routing_secret(&self) -> u64 {
        self.routing_secret.unwrap_or(0)
    }
    pub fn clear_routing_secret(&mut self) {
        self.routing_secret = ::std::option::Option::None;
    }

    pub fn has_routing_secret(&self) -> bool {
        self.routing_secret.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.ipv4 = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.ipv6)?;
                },
                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.port = ::std::option::Option::Some(tmp);
                },
                4 => {
                    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.routing_secret = ::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.ipv4 {
            my_size += 5;
        }
        if let Some(ref v) = self.ipv6.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(v) = self.port {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.routing_secret {
            my_size += 9;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.ipv4 {
            os.write_fixed32(1, v)?;
        }
        if let Some(ref v) = self.ipv6.as_ref() {
            os.write_bytes(2, &v)?;
        }
        if let Some(v) = self.port {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.routing_secret {
            os.write_fixed64(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() -> CMsgSteamDatagramHostedServerAddressPlaintext {
        CMsgSteamDatagramHostedServerAddressPlaintext::new()
    }

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

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

impl ::protobuf::Clear for CMsgSteamDatagramHostedServerAddressPlaintext {
    fn clear(&mut self) {
        self.ipv4 = ::std::option::Option::None;
        self.ipv6.clear();
        self.port = ::std::option::Option::None;
        self.routing_secret = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n!steamdatagram_messages_auth.proto\x1a+steamnetworkingsockets_messages\
    _certs.proto\"\xd3\x07\n\x20CMsgSteamDatagramRelayAuthTicket\x12\x1f\n\
    \x0btime_expiry\x18\x01\x20\x01(\x07R\ntimeExpiry\x12I\n!authorized_clie\
    nt_identity_string\x18\x0e\x20\x01(\tR\x1eauthorizedClientIdentityString\
    \x12<\n\x1agameserver_identity_string\x18\x0f\x20\x01(\tR\x18gameserverI\
    dentityString\x120\n\x14authorized_public_ip\x18\x03\x20\x01(\x07R\x12au\
    thorizedPublicIp\x12-\n\x12gameserver_address\x18\x0b\x20\x01(\x0cR\x11g\
    ameserverAddress\x12\x15\n\x06app_id\x18\x07\x20\x01(\rR\x05appId\x12!\n\
    \x0cvirtual_port\x18\n\x20\x01(\rR\x0bvirtualPort\x12O\n\x0cextra_fields\
    \x18\x08\x20\x03(\x0b2,.CMsgSteamDatagramRelayAuthTicket.ExtraFieldR\x0b\
    extraFields\x12;\n\x1alegacy_authorized_steam_id\x18\x02\x20\x01(\x06R\
    \x17legacyAuthorizedSteamId\x12;\n\x1alegacy_gameserver_steam_id\x18\x04\
    \x20\x01(\x06R\x17legacyGameserverSteamId\x127\n\x18legacy_gameserver_ne\
    t_id\x18\x05\x20\x01(\x06R\x15legacyGameserverNetId\x127\n\x18legacy_gam\
    eserver_pop_id\x18\t\x20\x01(\x07R\x15legacyGameserverPopId\x12V\n(legac\
    y_authorized_client_identity_binary\x18\x0c\x20\x01(\x0cR$legacyAuthoriz\
    edClientIdentityBinary\x12I\n!legacy_gameserver_identity_binary\x18\r\
    \x20\x01(\x0cR\x1elegacyGameserverIdentityBinary\x1a\x89\x01\n\nExtraFie\
    ld\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12!\n\x0cstring_value\
    \x18\x02\x20\x01(\tR\x0bstringValue\x12\x1f\n\x0bint64_value\x18\x03\x20\
    \x01(\x12R\nint64Value\x12#\n\rfixed64_value\x18\x05\x20\x01(\x06R\x0cfi\
    xed64Value\"\xa4\x01\n&CMsgSteamDatagramSignedRelayAuthTicket\x12-\n\x13\
    reserved_do_not_use\x18\x01\x20\x01(\x06R\x10reservedDoNotUse\x12\x15\n\
    \x06key_id\x18\x02\x20\x01(\x06R\x05keyId\x12\x16\n\x06ticket\x18\x03\
    \x20\x01(\x0cR\x06ticket\x12\x1c\n\tsignature\x18\x04\x20\x01(\x0cR\tsig\
    nature\"\x84\x01\n(CMsgSteamDatagramCachedCredentialsForApp\x12\x1f\n\
    \x0bprivate_key\x18\x01\x20\x01(\x0cR\nprivateKey\x12\x12\n\x04cert\x18\
    \x02\x20\x01(\x0cR\x04cert\x12#\n\rrelay_tickets\x18\x03\x20\x03(\x0cR\
    \x0crelayTickets\"\xa3\x02\n+CMsgSteamDatagramGameCoordinatorServerLogin\
    \x12%\n\x0etime_generated\x18\x01\x20\x01(\rR\rtimeGenerated\x12\x14\n\
    \x05appid\x18\x02\x20\x01(\rR\x05appid\x12\x18\n\x07routing\x18\x03\x20\
    \x01(\x0cR\x07routing\x12\x18\n\x07appdata\x18\x04\x20\x01(\x0cR\x07appd\
    ata\x124\n\x16legacy_identity_binary\x18\x05\x20\x01(\x0cR\x14legacyIden\
    tityBinary\x12'\n\x0fidentity_string\x18\x06\x20\x01(\tR\x0eidentityStri\
    ng\x12$\n\x0edummy_steam_id\x18c\x20\x01(\x06R\x0cdummySteamId\"\xa0\x01\
    \n1CMsgSteamDatagramSignedGameCoordinatorServerLogin\x127\n\x04cert\x18\
    \x01\x20\x01(\x0b2#.CMsgSteamDatagramCertificateSignedR\x04cert\x12\x14\
    \n\x05login\x18\x02\x20\x01(\x0cR\x05login\x12\x1c\n\tsignature\x18\x03\
    \x20\x01(\x0cR\tsignature\"\x92\x01\n-CMsgSteamDatagramHostedServerAddre\
    ssPlaintext\x12\x12\n\x04ipv4\x18\x01\x20\x01(\x07R\x04ipv4\x12\x12\n\
    \x04ipv6\x18\x02\x20\x01(\x0cR\x04ipv6\x12\x12\n\x04port\x18\x03\x20\x01\
    (\rR\x04port\x12%\n\x0erouting_secret\x18\x04\x20\x01(\x06R\rroutingSecr\
    etB\x05H\x01\x80\x01\0\
";

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