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

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

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

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

//! Generated file from `steamdatagram_messages_sdr.proto`
// Generated for lite runtime

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

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

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

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

    // optional fixed32 v4 = 1;

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

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

    pub fn has_v4(&self) -> bool {
        self.v4.is_some()
    }

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

    // optional bytes v6 = 2;

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

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

    pub fn has_v6(&self) -> bool {
        self.v6.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

// @@protoc_insertion_point(message:CMsgSteamDatagramSignedMessageGeneric)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramSignedMessageGeneric {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramSignedMessageGeneric.cert)
    pub cert: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramSignedMessageGeneric.signed_data)
    pub signed_data: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramSignedMessageGeneric.signature)
    pub signature: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramSignedMessageGeneric.dummy_pad)
    pub dummy_pad: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramSignedMessageGeneric.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional bytes signed_data = 2;

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

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

    pub fn has_signed_data(&self) -> bool {
        self.signed_data.is_some()
    }

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

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

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

    // optional bytes signature = 3;

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

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

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

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

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

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

    // optional bytes dummy_pad = 1023;

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

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

    pub fn has_dummy_pad(&self) -> bool {
        self.dummy_pad.is_some()
    }

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.cert)?;
                },
                18 => {
                    self.signed_data = ::std::option::Option::Some(is.read_bytes()?);
                },
                26 => {
                    self.signature = ::std::option::Option::Some(is.read_bytes()?);
                },
                8186 => {
                    self.dummy_pad = ::std::option::Option::Some(is.read_bytes()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn clear(&mut self) {
        self.cert.clear();
        self.signed_data = ::std::option::Option::None;
        self.signature = ::std::option::Option::None;
        self.dummy_pad = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramSignedMessageGeneric {
        static instance: CMsgSteamDatagramSignedMessageGeneric = CMsgSteamDatagramSignedMessageGeneric {
            cert: ::steam_vent_proto_common::protobuf::MessageField::none(),
            signed_data: ::std::option::Option::None,
            signature: ::std::option::Option::None,
            dummy_pad: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramRouterPingReply)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramRouterPingReply {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.client_timestamp)
    pub client_timestamp: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.latency_datacenter_ids)
    pub latency_datacenter_ids: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.latency_ping_ms)
    pub latency_ping_ms: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.latency_datacenter_ids_p2p)
    pub latency_datacenter_ids_p2p: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.latency_ping_ms_p2p)
    pub latency_ping_ms_p2p: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.your_public_ip)
    pub your_public_ip: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.your_public_port)
    pub your_public_port: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.server_time)
    pub server_time: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.challenge)
    pub challenge: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.seconds_until_shutdown)
    pub seconds_until_shutdown: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.client_cookie)
    pub client_cookie: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.recv_tos)
    pub recv_tos: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.echo_sent_tos)
    pub echo_sent_tos: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.sent_tos)
    pub sent_tos: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.echo_request_reply_tos)
    pub echo_request_reply_tos: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.scoring_penalty_relay_cluster)
    pub scoring_penalty_relay_cluster: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.flags)
    pub flags: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.route_exceptions)
    pub route_exceptions: ::std::vec::Vec<cmsg_steam_datagram_router_ping_reply::RouteException>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.alt_addresses)
    pub alt_addresses: ::std::vec::Vec<cmsg_steam_datagram_router_ping_reply::AltAddress>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.dummy_pad)
    pub dummy_pad: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.dummy_varint)
    pub dummy_varint: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramRouterPingReply.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed32 client_timestamp = 1;

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

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

    pub fn has_client_timestamp(&self) -> bool {
        self.client_timestamp.is_some()
    }

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

    // optional fixed32 your_public_ip = 4;

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

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

    pub fn has_your_public_ip(&self) -> bool {
        self.your_public_ip.is_some()
    }

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

    // optional fixed32 your_public_port = 11;

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

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

    pub fn has_your_public_port(&self) -> bool {
        self.your_public_port.is_some()
    }

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

    // optional fixed32 server_time = 5;

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

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

    pub fn has_server_time(&self) -> bool {
        self.server_time.is_some()
    }

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

    // optional fixed64 challenge = 6;

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

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

    pub fn has_challenge(&self) -> bool {
        self.challenge.is_some()
    }

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

    // optional uint32 seconds_until_shutdown = 7;

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

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

    pub fn has_seconds_until_shutdown(&self) -> bool {
        self.seconds_until_shutdown.is_some()
    }

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

    // optional fixed32 client_cookie = 8;

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

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

    pub fn has_client_cookie(&self) -> bool {
        self.client_cookie.is_some()
    }

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

    // optional uint32 recv_tos = 16;

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

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

    pub fn has_recv_tos(&self) -> bool {
        self.recv_tos.is_some()
    }

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

    // optional uint32 echo_sent_tos = 17;

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

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

    pub fn has_echo_sent_tos(&self) -> bool {
        self.echo_sent_tos.is_some()
    }

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

    // optional uint32 sent_tos = 18;

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

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

    pub fn has_sent_tos(&self) -> bool {
        self.sent_tos.is_some()
    }

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

    // optional uint32 echo_request_reply_tos = 19;

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

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

    pub fn has_echo_request_reply_tos(&self) -> bool {
        self.echo_request_reply_tos.is_some()
    }

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

    // optional uint32 scoring_penalty_relay_cluster = 9;

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

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

    pub fn has_scoring_penalty_relay_cluster(&self) -> bool {
        self.scoring_penalty_relay_cluster.is_some()
    }

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

    // optional uint32 flags = 12;

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

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

    pub fn has_flags(&self) -> bool {
        self.flags.is_some()
    }

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

    // optional bytes dummy_pad = 99;

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

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

    pub fn has_dummy_pad(&self) -> bool {
        self.dummy_pad.is_some()
    }

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

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

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

    // optional uint64 dummy_varint = 100;

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

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

    pub fn has_dummy_varint(&self) -> bool {
        self.dummy_varint.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                13 => {
                    self.client_timestamp = ::std::option::Option::Some(is.read_fixed32()?);
                },
                18 => {
                    is.read_repeated_packed_fixed32_into(&mut self.latency_datacenter_ids)?;
                },
                21 => {
                    self.latency_datacenter_ids.push(is.read_fixed32()?);
                },
                26 => {
                    is.read_repeated_packed_uint32_into(&mut self.latency_ping_ms)?;
                },
                24 => {
                    self.latency_ping_ms.push(is.read_uint32()?);
                },
                114 => {
                    is.read_repeated_packed_fixed32_into(&mut self.latency_datacenter_ids_p2p)?;
                },
                117 => {
                    self.latency_datacenter_ids_p2p.push(is.read_fixed32()?);
                },
                122 => {
                    is.read_repeated_packed_uint32_into(&mut self.latency_ping_ms_p2p)?;
                },
                120 => {
                    self.latency_ping_ms_p2p.push(is.read_uint32()?);
                },
                37 => {
                    self.your_public_ip = ::std::option::Option::Some(is.read_fixed32()?);
                },
                93 => {
                    self.your_public_port = ::std::option::Option::Some(is.read_fixed32()?);
                },
                45 => {
                    self.server_time = ::std::option::Option::Some(is.read_fixed32()?);
                },
                49 => {
                    self.challenge = ::std::option::Option::Some(is.read_fixed64()?);
                },
                56 => {
                    self.seconds_until_shutdown = ::std::option::Option::Some(is.read_uint32()?);
                },
                69 => {
                    self.client_cookie = ::std::option::Option::Some(is.read_fixed32()?);
                },
                128 => {
                    self.recv_tos = ::std::option::Option::Some(is.read_uint32()?);
                },
                136 => {
                    self.echo_sent_tos = ::std::option::Option::Some(is.read_uint32()?);
                },
                144 => {
                    self.sent_tos = ::std::option::Option::Some(is.read_uint32()?);
                },
                152 => {
                    self.echo_request_reply_tos = ::std::option::Option::Some(is.read_uint32()?);
                },
                72 => {
                    self.scoring_penalty_relay_cluster = ::std::option::Option::Some(is.read_uint32()?);
                },
                96 => {
                    self.flags = ::std::option::Option::Some(is.read_uint32()?);
                },
                82 => {
                    self.route_exceptions.push(is.read_message()?);
                },
                106 => {
                    self.alt_addresses.push(is.read_message()?);
                },
                794 => {
                    self.dummy_pad = ::std::option::Option::Some(is.read_bytes()?);
                },
                800 => {
                    self.dummy_varint = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.client_timestamp {
            my_size += 1 + 4;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::vec_packed_fixed32_size(2, &self.latency_datacenter_ids);
        my_size += ::steam_vent_proto_common::protobuf::rt::vec_packed_uint32_size(3, &self.latency_ping_ms);
        my_size += ::steam_vent_proto_common::protobuf::rt::vec_packed_fixed32_size(14, &self.latency_datacenter_ids_p2p);
        my_size += ::steam_vent_proto_common::protobuf::rt::vec_packed_uint32_size(15, &self.latency_ping_ms_p2p);
        if let Some(v) = self.your_public_ip {
            my_size += 1 + 4;
        }
        if let Some(v) = self.your_public_port {
            my_size += 1 + 4;
        }
        if let Some(v) = self.server_time {
            my_size += 1 + 4;
        }
        if let Some(v) = self.challenge {
            my_size += 1 + 8;
        }
        if let Some(v) = self.seconds_until_shutdown {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.client_cookie {
            my_size += 1 + 4;
        }
        if let Some(v) = self.recv_tos {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(16, v);
        }
        if let Some(v) = self.echo_sent_tos {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(17, v);
        }
        if let Some(v) = self.sent_tos {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(18, v);
        }
        if let Some(v) = self.echo_request_reply_tos {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(19, v);
        }
        if let Some(v) = self.scoring_penalty_relay_cluster {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
        }
        if let Some(v) = self.flags {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(12, v);
        }
        for value in &self.route_exceptions {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.alt_addresses {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.dummy_pad.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(99, &v);
        }
        if let Some(v) = self.dummy_varint {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(100, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.client_timestamp {
            os.write_fixed32(1, v)?;
        }
        os.write_repeated_packed_fixed32(2, &self.latency_datacenter_ids)?;
        os.write_repeated_packed_uint32(3, &self.latency_ping_ms)?;
        os.write_repeated_packed_fixed32(14, &self.latency_datacenter_ids_p2p)?;
        os.write_repeated_packed_uint32(15, &self.latency_ping_ms_p2p)?;
        if let Some(v) = self.your_public_ip {
            os.write_fixed32(4, v)?;
        }
        if let Some(v) = self.your_public_port {
            os.write_fixed32(11, v)?;
        }
        if let Some(v) = self.server_time {
            os.write_fixed32(5, v)?;
        }
        if let Some(v) = self.challenge {
            os.write_fixed64(6, v)?;
        }
        if let Some(v) = self.seconds_until_shutdown {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.client_cookie {
            os.write_fixed32(8, v)?;
        }
        if let Some(v) = self.recv_tos {
            os.write_uint32(16, v)?;
        }
        if let Some(v) = self.echo_sent_tos {
            os.write_uint32(17, v)?;
        }
        if let Some(v) = self.sent_tos {
            os.write_uint32(18, v)?;
        }
        if let Some(v) = self.echo_request_reply_tos {
            os.write_uint32(19, v)?;
        }
        if let Some(v) = self.scoring_penalty_relay_cluster {
            os.write_uint32(9, v)?;
        }
        if let Some(v) = self.flags {
            os.write_uint32(12, v)?;
        }
        for v in &self.route_exceptions {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
        };
        for v in &self.alt_addresses {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(13, v, os)?;
        };
        if let Some(v) = self.dummy_pad.as_ref() {
            os.write_bytes(99, v)?;
        }
        if let Some(v) = self.dummy_varint {
            os.write_uint64(100, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.client_timestamp = ::std::option::Option::None;
        self.latency_datacenter_ids.clear();
        self.latency_ping_ms.clear();
        self.latency_datacenter_ids_p2p.clear();
        self.latency_ping_ms_p2p.clear();
        self.your_public_ip = ::std::option::Option::None;
        self.your_public_port = ::std::option::Option::None;
        self.server_time = ::std::option::Option::None;
        self.challenge = ::std::option::Option::None;
        self.seconds_until_shutdown = ::std::option::Option::None;
        self.client_cookie = ::std::option::Option::None;
        self.recv_tos = ::std::option::Option::None;
        self.echo_sent_tos = ::std::option::Option::None;
        self.sent_tos = ::std::option::Option::None;
        self.echo_request_reply_tos = ::std::option::Option::None;
        self.scoring_penalty_relay_cluster = ::std::option::Option::None;
        self.flags = ::std::option::Option::None;
        self.route_exceptions.clear();
        self.alt_addresses.clear();
        self.dummy_pad = ::std::option::Option::None;
        self.dummy_varint = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramRouterPingReply {
        static instance: CMsgSteamDatagramRouterPingReply = CMsgSteamDatagramRouterPingReply {
            client_timestamp: ::std::option::Option::None,
            latency_datacenter_ids: ::std::vec::Vec::new(),
            latency_ping_ms: ::std::vec::Vec::new(),
            latency_datacenter_ids_p2p: ::std::vec::Vec::new(),
            latency_ping_ms_p2p: ::std::vec::Vec::new(),
            your_public_ip: ::std::option::Option::None,
            your_public_port: ::std::option::Option::None,
            server_time: ::std::option::Option::None,
            challenge: ::std::option::Option::None,
            seconds_until_shutdown: ::std::option::Option::None,
            client_cookie: ::std::option::Option::None,
            recv_tos: ::std::option::Option::None,
            echo_sent_tos: ::std::option::Option::None,
            sent_tos: ::std::option::Option::None,
            echo_request_reply_tos: ::std::option::Option::None,
            scoring_penalty_relay_cluster: ::std::option::Option::None,
            flags: ::std::option::Option::None,
            route_exceptions: ::std::vec::Vec::new(),
            alt_addresses: ::std::vec::Vec::new(),
            dummy_pad: ::std::option::Option::None,
            dummy_varint: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CMsgSteamDatagramRouterPingReply`
pub mod cmsg_steam_datagram_router_ping_reply {
    // @@protoc_insertion_point(message:CMsgSteamDatagramRouterPingReply.RouteException)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct RouteException {
        // message fields
        // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.RouteException.data_center_id)
        pub data_center_id: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.RouteException.flags)
        pub flags: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.RouteException.penalty)
        pub penalty: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CMsgSteamDatagramRouterPingReply.RouteException.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional fixed32 data_center_id = 1;

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

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

        pub fn has_data_center_id(&self) -> bool {
            self.data_center_id.is_some()
        }

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

        // optional uint32 flags = 2;

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

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

        pub fn has_flags(&self) -> bool {
            self.flags.is_some()
        }

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

        // optional uint32 penalty = 3;

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

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

        pub fn has_penalty(&self) -> bool {
            self.penalty.is_some()
        }

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

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

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

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    13 => {
                        self.data_center_id = ::std::option::Option::Some(is.read_fixed32()?);
                    },
                    16 => {
                        self.flags = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    24 => {
                        self.penalty = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

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

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

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

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

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

    // @@protoc_insertion_point(message:CMsgSteamDatagramRouterPingReply.AltAddress)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct AltAddress {
        // message fields
        // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.AltAddress.ipv4)
        pub ipv4: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.AltAddress.port)
        pub port: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.AltAddress.penalty)
        pub penalty: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.AltAddress.protocol)
        pub protocol: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<alt_address::Protocol>>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramRouterPingReply.AltAddress.id)
        pub id: ::std::option::Option<::std::string::String>,
        // special fields
        // @@protoc_insertion_point(special_field:CMsgSteamDatagramRouterPingReply.AltAddress.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional fixed32 ipv4 = 1;

        pub fn 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 uint32 port = 2;

        pub fn 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 uint32 penalty = 3;

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

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

        pub fn has_penalty(&self) -> bool {
            self.penalty.is_some()
        }

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

        // optional .CMsgSteamDatagramRouterPingReply.AltAddress.Protocol protocol = 4;

        pub fn protocol(&self) -> alt_address::Protocol {
            match self.protocol {
                Some(e) => e.enum_value_or(alt_address::Protocol::DefaultProtocol),
                None => alt_address::Protocol::DefaultProtocol,
            }
        }

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

        pub fn has_protocol(&self) -> bool {
            self.protocol.is_some()
        }

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

        // optional string id = 5;

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

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

        pub fn has_id(&self) -> bool {
            self.id.is_some()
        }

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

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

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

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

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

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    13 => {
                        self.ipv4 = ::std::option::Option::Some(is.read_fixed32()?);
                    },
                    16 => {
                        self.port = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    24 => {
                        self.penalty = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    32 => {
                        self.protocol = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                    },
                    42 => {
                        self.id = ::std::option::Option::Some(is.read_string()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.ipv4 {
                os.write_fixed32(1, v)?;
            }
            if let Some(v) = self.port {
                os.write_uint32(2, v)?;
            }
            if let Some(v) = self.penalty {
                os.write_uint32(3, v)?;
            }
            if let Some(v) = self.protocol {
                os.write_enum(4, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
            }
            if let Some(v) = self.id.as_ref() {
                os.write_string(5, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

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

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

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

        fn clear(&mut self) {
            self.ipv4 = ::std::option::Option::None;
            self.port = ::std::option::Option::None;
            self.penalty = ::std::option::Option::None;
            self.protocol = ::std::option::Option::None;
            self.id = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static AltAddress {
            static instance: AltAddress = AltAddress {
                ipv4: ::std::option::Option::None,
                port: ::std::option::Option::None,
                penalty: ::std::option::Option::None,
                protocol: ::std::option::Option::None,
                id: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `AltAddress`
    pub mod alt_address {
        #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
        // @@protoc_insertion_point(enum:CMsgSteamDatagramRouterPingReply.AltAddress.Protocol)
        pub enum Protocol {
            // @@protoc_insertion_point(enum_value:CMsgSteamDatagramRouterPingReply.AltAddress.Protocol.DefaultProtocol)
            DefaultProtocol = 0,
        }

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

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

            fn from_i32(value: i32) -> ::std::option::Option<Protocol> {
                match value {
                    0 => ::std::option::Option::Some(Protocol::DefaultProtocol),
                    _ => ::std::option::Option::None
                }
            }

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

            const VALUES: &'static [Protocol] = &[
                Protocol::DefaultProtocol,
            ];
        }

        impl ::std::default::Default for Protocol {
            fn default() -> Self {
                Protocol::DefaultProtocol
            }
        }

    }

    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    // @@protoc_insertion_point(enum:CMsgSteamDatagramRouterPingReply.Flags)
    pub enum Flags {
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramRouterPingReply.Flags.FLAG_MAYBE_MORE_DATA_CENTERS)
        FLAG_MAYBE_MORE_DATA_CENTERS = 1,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramRouterPingReply.Flags.FLAG_MAYBE_MORE_ALT_ADDRESSES)
        FLAG_MAYBE_MORE_ALT_ADDRESSES = 2,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<Flags> {
            match value {
                1 => ::std::option::Option::Some(Flags::FLAG_MAYBE_MORE_DATA_CENTERS),
                2 => ::std::option::Option::Some(Flags::FLAG_MAYBE_MORE_ALT_ADDRESSES),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Flags> {
            match str {
                "FLAG_MAYBE_MORE_DATA_CENTERS" => ::std::option::Option::Some(Flags::FLAG_MAYBE_MORE_DATA_CENTERS),
                "FLAG_MAYBE_MORE_ALT_ADDRESSES" => ::std::option::Option::Some(Flags::FLAG_MAYBE_MORE_ALT_ADDRESSES),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Flags] = &[
            Flags::FLAG_MAYBE_MORE_DATA_CENTERS,
            Flags::FLAG_MAYBE_MORE_ALT_ADDRESSES,
        ];
    }

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

}

// @@protoc_insertion_point(message:CMsgSteamDatagramGameserverPingRequestBody)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramGameserverPingRequestBody {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestBody.relay_popid)
    pub relay_popid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestBody.your_public_ip)
    pub your_public_ip: ::steam_vent_proto_common::protobuf::MessageField<CMsgSteamNetworkingIPAddress>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestBody.your_public_port)
    pub your_public_port: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestBody.relay_unix_time)
    pub relay_unix_time: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestBody.routing_secret)
    pub routing_secret: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestBody.my_ips)
    pub my_ips: ::std::vec::Vec<CMsgSteamNetworkingIPAddress>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestBody.echo)
    pub echo: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramGameserverPingRequestBody.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed32 relay_popid = 1;

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

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

    pub fn has_relay_popid(&self) -> bool {
        self.relay_popid.is_some()
    }

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

    // optional uint32 your_public_port = 3;

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

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

    pub fn has_your_public_port(&self) -> bool {
        self.your_public_port.is_some()
    }

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

    // optional uint64 relay_unix_time = 4;

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

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

    pub fn has_relay_unix_time(&self) -> bool {
        self.relay_unix_time.is_some()
    }

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

    // optional fixed64 routing_secret = 5;

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

    // optional bytes echo = 8;

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

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

    pub fn has_echo(&self) -> bool {
        self.echo.is_some()
    }

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                13 => {
                    self.relay_popid = ::std::option::Option::Some(is.read_fixed32()?);
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.your_public_ip)?;
                },
                24 => {
                    self.your_public_port = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.relay_unix_time = ::std::option::Option::Some(is.read_uint64()?);
                },
                41 => {
                    self.routing_secret = ::std::option::Option::Some(is.read_fixed64()?);
                },
                50 => {
                    self.my_ips.push(is.read_message()?);
                },
                66 => {
                    self.echo = ::std::option::Option::Some(is.read_bytes()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.relay_popid {
            my_size += 1 + 4;
        }
        if let Some(v) = self.your_public_ip.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.your_public_port {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.relay_unix_time {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(4, v);
        }
        if let Some(v) = self.routing_secret {
            my_size += 1 + 8;
        }
        for value in &self.my_ips {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.echo.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(8, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.relay_popid {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.your_public_ip.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if let Some(v) = self.your_public_port {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.relay_unix_time {
            os.write_uint64(4, v)?;
        }
        if let Some(v) = self.routing_secret {
            os.write_fixed64(5, v)?;
        }
        for v in &self.my_ips {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        };
        if let Some(v) = self.echo.as_ref() {
            os.write_bytes(8, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.relay_popid = ::std::option::Option::None;
        self.your_public_ip.clear();
        self.your_public_port = ::std::option::Option::None;
        self.relay_unix_time = ::std::option::Option::None;
        self.routing_secret = ::std::option::Option::None;
        self.my_ips.clear();
        self.echo = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramGameserverPingRequestBody {
        static instance: CMsgSteamDatagramGameserverPingRequestBody = CMsgSteamDatagramGameserverPingRequestBody {
            relay_popid: ::std::option::Option::None,
            your_public_ip: ::steam_vent_proto_common::protobuf::MessageField::none(),
            your_public_port: ::std::option::Option::None,
            relay_unix_time: ::std::option::Option::None,
            routing_secret: ::std::option::Option::None,
            my_ips: ::std::vec::Vec::new(),
            echo: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramGameserverPingRequestEnvelope)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramGameserverPingRequestEnvelope {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestEnvelope.cert)
    pub cert: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestEnvelope.signed_data)
    pub signed_data: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestEnvelope.signature)
    pub signature: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestEnvelope.legacy_your_public_ip)
    pub legacy_your_public_ip: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestEnvelope.legacy_your_public_port)
    pub legacy_your_public_port: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestEnvelope.legacy_relay_unix_time)
    pub legacy_relay_unix_time: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestEnvelope.legacy_challenge)
    pub legacy_challenge: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestEnvelope.legacy_router_timestamp)
    pub legacy_router_timestamp: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingRequestEnvelope.dummy_pad)
    pub dummy_pad: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramGameserverPingRequestEnvelope.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional bytes signed_data = 7;

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

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

    pub fn has_signed_data(&self) -> bool {
        self.signed_data.is_some()
    }

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

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

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

    // optional bytes signature = 8;

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

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

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

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

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

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

    // optional fixed32 legacy_your_public_ip = 1;

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

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

    pub fn has_legacy_your_public_ip(&self) -> bool {
        self.legacy_your_public_ip.is_some()
    }

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

    // optional fixed32 legacy_your_public_port = 5;

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

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

    pub fn has_legacy_your_public_port(&self) -> bool {
        self.legacy_your_public_port.is_some()
    }

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

    // optional fixed32 legacy_relay_unix_time = 2;

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

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

    pub fn has_legacy_relay_unix_time(&self) -> bool {
        self.legacy_relay_unix_time.is_some()
    }

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

    // optional fixed64 legacy_challenge = 3;

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

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

    pub fn has_legacy_challenge(&self) -> bool {
        self.legacy_challenge.is_some()
    }

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

    // optional fixed32 legacy_router_timestamp = 4;

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

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

    pub fn has_legacy_router_timestamp(&self) -> bool {
        self.legacy_router_timestamp.is_some()
    }

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

    // optional bytes dummy_pad = 1023;

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

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

    pub fn has_dummy_pad(&self) -> bool {
        self.dummy_pad.is_some()
    }

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                50 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.cert)?;
                },
                58 => {
                    self.signed_data = ::std::option::Option::Some(is.read_bytes()?);
                },
                66 => {
                    self.signature = ::std::option::Option::Some(is.read_bytes()?);
                },
                13 => {
                    self.legacy_your_public_ip = ::std::option::Option::Some(is.read_fixed32()?);
                },
                45 => {
                    self.legacy_your_public_port = ::std::option::Option::Some(is.read_fixed32()?);
                },
                21 => {
                    self.legacy_relay_unix_time = ::std::option::Option::Some(is.read_fixed32()?);
                },
                25 => {
                    self.legacy_challenge = ::std::option::Option::Some(is.read_fixed64()?);
                },
                37 => {
                    self.legacy_router_timestamp = ::std::option::Option::Some(is.read_fixed32()?);
                },
                8186 => {
                    self.dummy_pad = ::std::option::Option::Some(is.read_bytes()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.cert.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.signed_data.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(7, &v);
        }
        if let Some(v) = self.signature.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(8, &v);
        }
        if let Some(v) = self.legacy_your_public_ip {
            my_size += 1 + 4;
        }
        if let Some(v) = self.legacy_your_public_port {
            my_size += 1 + 4;
        }
        if let Some(v) = self.legacy_relay_unix_time {
            my_size += 1 + 4;
        }
        if let Some(v) = self.legacy_challenge {
            my_size += 1 + 8;
        }
        if let Some(v) = self.legacy_router_timestamp {
            my_size += 1 + 4;
        }
        if let Some(v) = self.dummy_pad.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(1023, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.cert.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        }
        if let Some(v) = self.signed_data.as_ref() {
            os.write_bytes(7, v)?;
        }
        if let Some(v) = self.signature.as_ref() {
            os.write_bytes(8, v)?;
        }
        if let Some(v) = self.legacy_your_public_ip {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.legacy_your_public_port {
            os.write_fixed32(5, v)?;
        }
        if let Some(v) = self.legacy_relay_unix_time {
            os.write_fixed32(2, v)?;
        }
        if let Some(v) = self.legacy_challenge {
            os.write_fixed64(3, v)?;
        }
        if let Some(v) = self.legacy_router_timestamp {
            os.write_fixed32(4, v)?;
        }
        if let Some(v) = self.dummy_pad.as_ref() {
            os.write_bytes(1023, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.cert.clear();
        self.signed_data = ::std::option::Option::None;
        self.signature = ::std::option::Option::None;
        self.legacy_your_public_ip = ::std::option::Option::None;
        self.legacy_your_public_port = ::std::option::Option::None;
        self.legacy_relay_unix_time = ::std::option::Option::None;
        self.legacy_challenge = ::std::option::Option::None;
        self.legacy_router_timestamp = ::std::option::Option::None;
        self.dummy_pad = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramGameserverPingRequestEnvelope {
        static instance: CMsgSteamDatagramGameserverPingRequestEnvelope = CMsgSteamDatagramGameserverPingRequestEnvelope {
            cert: ::steam_vent_proto_common::protobuf::MessageField::none(),
            signed_data: ::std::option::Option::None,
            signature: ::std::option::Option::None,
            legacy_your_public_ip: ::std::option::Option::None,
            legacy_your_public_port: ::std::option::Option::None,
            legacy_relay_unix_time: ::std::option::Option::None,
            legacy_challenge: ::std::option::Option::None,
            legacy_router_timestamp: ::std::option::Option::None,
            dummy_pad: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramGameserverPingReplyData)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramGameserverPingReplyData {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingReplyData.echo_relay_unix_time)
    pub echo_relay_unix_time: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingReplyData.echo)
    pub echo: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingReplyData.legacy_challenge)
    pub legacy_challenge: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingReplyData.legacy_router_timestamp)
    pub legacy_router_timestamp: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingReplyData.data_center_id)
    pub data_center_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingReplyData.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingReplyData.protocol_version)
    pub protocol_version: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingReplyData.build)
    pub build: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingReplyData.network_config_version)
    pub network_config_version: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingReplyData.my_unix_time)
    pub my_unix_time: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverPingReplyData.routing_blob)
    pub routing_blob: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramGameserverPingReplyData.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed32 echo_relay_unix_time = 2;

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

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

    pub fn has_echo_relay_unix_time(&self) -> bool {
        self.echo_relay_unix_time.is_some()
    }

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

    // optional bytes echo = 8;

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

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

    pub fn has_echo(&self) -> bool {
        self.echo.is_some()
    }

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

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

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

    // optional fixed64 legacy_challenge = 3;

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

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

    pub fn has_legacy_challenge(&self) -> bool {
        self.legacy_challenge.is_some()
    }

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

    // optional fixed32 legacy_router_timestamp = 4;

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

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

    pub fn has_legacy_router_timestamp(&self) -> bool {
        self.legacy_router_timestamp.is_some()
    }

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

    // optional fixed32 data_center_id = 5;

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

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

    pub fn has_data_center_id(&self) -> bool {
        self.data_center_id.is_some()
    }

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

    // optional uint32 appid = 6;

    pub fn 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 uint32 protocol_version = 7;

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

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

    pub fn has_protocol_version(&self) -> bool {
        self.protocol_version.is_some()
    }

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

    // optional string build = 9;

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

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

    pub fn has_build(&self) -> bool {
        self.build.is_some()
    }

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

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

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

    // optional uint64 network_config_version = 10;

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

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

    pub fn has_network_config_version(&self) -> bool {
        self.network_config_version.is_some()
    }

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

    // optional fixed32 my_unix_time = 11;

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

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

    pub fn has_my_unix_time(&self) -> bool {
        self.my_unix_time.is_some()
    }

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

    // optional bytes routing_blob = 12;

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

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

    pub fn has_routing_blob(&self) -> bool {
        self.routing_blob.is_some()
    }

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                21 => {
                    self.echo_relay_unix_time = ::std::option::Option::Some(is.read_fixed32()?);
                },
                66 => {
                    self.echo = ::std::option::Option::Some(is.read_bytes()?);
                },
                25 => {
                    self.legacy_challenge = ::std::option::Option::Some(is.read_fixed64()?);
                },
                37 => {
                    self.legacy_router_timestamp = ::std::option::Option::Some(is.read_fixed32()?);
                },
                45 => {
                    self.data_center_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                48 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                56 => {
                    self.protocol_version = ::std::option::Option::Some(is.read_uint32()?);
                },
                74 => {
                    self.build = ::std::option::Option::Some(is.read_string()?);
                },
                80 => {
                    self.network_config_version = ::std::option::Option::Some(is.read_uint64()?);
                },
                93 => {
                    self.my_unix_time = ::std::option::Option::Some(is.read_fixed32()?);
                },
                98 => {
                    self.routing_blob = ::std::option::Option::Some(is.read_bytes()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.echo_relay_unix_time {
            my_size += 1 + 4;
        }
        if let Some(v) = self.echo.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(8, &v);
        }
        if let Some(v) = self.legacy_challenge {
            my_size += 1 + 8;
        }
        if let Some(v) = self.legacy_router_timestamp {
            my_size += 1 + 4;
        }
        if let Some(v) = self.data_center_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.protocol_version {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.build.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &v);
        }
        if let Some(v) = self.network_config_version {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(10, v);
        }
        if let Some(v) = self.my_unix_time {
            my_size += 1 + 4;
        }
        if let Some(v) = self.routing_blob.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(12, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.echo_relay_unix_time {
            os.write_fixed32(2, v)?;
        }
        if let Some(v) = self.echo.as_ref() {
            os.write_bytes(8, v)?;
        }
        if let Some(v) = self.legacy_challenge {
            os.write_fixed64(3, v)?;
        }
        if let Some(v) = self.legacy_router_timestamp {
            os.write_fixed32(4, v)?;
        }
        if let Some(v) = self.data_center_id {
            os.write_fixed32(5, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.protocol_version {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.build.as_ref() {
            os.write_string(9, v)?;
        }
        if let Some(v) = self.network_config_version {
            os.write_uint64(10, v)?;
        }
        if let Some(v) = self.my_unix_time {
            os.write_fixed32(11, v)?;
        }
        if let Some(v) = self.routing_blob.as_ref() {
            os.write_bytes(12, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.echo_relay_unix_time = ::std::option::Option::None;
        self.echo = ::std::option::Option::None;
        self.legacy_challenge = ::std::option::Option::None;
        self.legacy_router_timestamp = ::std::option::Option::None;
        self.data_center_id = ::std::option::Option::None;
        self.appid = ::std::option::Option::None;
        self.protocol_version = ::std::option::Option::None;
        self.build = ::std::option::Option::None;
        self.network_config_version = ::std::option::Option::None;
        self.my_unix_time = ::std::option::Option::None;
        self.routing_blob = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramGameserverPingReplyData {
        static instance: CMsgSteamDatagramGameserverPingReplyData = CMsgSteamDatagramGameserverPingReplyData {
            echo_relay_unix_time: ::std::option::Option::None,
            echo: ::std::option::Option::None,
            legacy_challenge: ::std::option::Option::None,
            legacy_router_timestamp: ::std::option::Option::None,
            data_center_id: ::std::option::Option::None,
            appid: ::std::option::Option::None,
            protocol_version: ::std::option::Option::None,
            build: ::std::option::Option::None,
            network_config_version: ::std::option::Option::None,
            my_unix_time: ::std::option::Option::None,
            routing_blob: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramNoSessionRelayToClient)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramNoSessionRelayToClient {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoSessionRelayToClient.connection_id)
    pub connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoSessionRelayToClient.your_public_ip)
    pub your_public_ip: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoSessionRelayToClient.your_public_port)
    pub your_public_port: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoSessionRelayToClient.server_time)
    pub server_time: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoSessionRelayToClient.challenge)
    pub challenge: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoSessionRelayToClient.seconds_until_shutdown)
    pub seconds_until_shutdown: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramNoSessionRelayToClient.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed32 connection_id = 7;

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

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

    pub fn has_connection_id(&self) -> bool {
        self.connection_id.is_some()
    }

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

    // optional fixed32 your_public_ip = 2;

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

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

    pub fn has_your_public_ip(&self) -> bool {
        self.your_public_ip.is_some()
    }

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

    // optional fixed32 your_public_port = 6;

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

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

    pub fn has_your_public_port(&self) -> bool {
        self.your_public_port.is_some()
    }

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

    // optional fixed32 server_time = 3;

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

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

    pub fn has_server_time(&self) -> bool {
        self.server_time.is_some()
    }

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

    // optional fixed64 challenge = 4;

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

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

    pub fn has_challenge(&self) -> bool {
        self.challenge.is_some()
    }

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

    // optional uint32 seconds_until_shutdown = 5;

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

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

    pub fn has_seconds_until_shutdown(&self) -> bool {
        self.seconds_until_shutdown.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                61 => {
                    self.connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                21 => {
                    self.your_public_ip = ::std::option::Option::Some(is.read_fixed32()?);
                },
                53 => {
                    self.your_public_port = ::std::option::Option::Some(is.read_fixed32()?);
                },
                29 => {
                    self.server_time = ::std::option::Option::Some(is.read_fixed32()?);
                },
                33 => {
                    self.challenge = ::std::option::Option::Some(is.read_fixed64()?);
                },
                40 => {
                    self.seconds_until_shutdown = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.connection_id {
            os.write_fixed32(7, v)?;
        }
        if let Some(v) = self.your_public_ip {
            os.write_fixed32(2, v)?;
        }
        if let Some(v) = self.your_public_port {
            os.write_fixed32(6, v)?;
        }
        if let Some(v) = self.server_time {
            os.write_fixed32(3, v)?;
        }
        if let Some(v) = self.challenge {
            os.write_fixed64(4, v)?;
        }
        if let Some(v) = self.seconds_until_shutdown {
            os.write_uint32(5, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.connection_id = ::std::option::Option::None;
        self.your_public_ip = ::std::option::Option::None;
        self.your_public_port = ::std::option::Option::None;
        self.server_time = ::std::option::Option::None;
        self.challenge = ::std::option::Option::None;
        self.seconds_until_shutdown = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramNoSessionRelayToClient {
        static instance: CMsgSteamDatagramNoSessionRelayToClient = CMsgSteamDatagramNoSessionRelayToClient {
            connection_id: ::std::option::Option::None,
            your_public_ip: ::std::option::Option::None,
            your_public_port: ::std::option::Option::None,
            server_time: ::std::option::Option::None,
            challenge: ::std::option::Option::None,
            seconds_until_shutdown: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional uint32 legacy_relay_session_id = 1;

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

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

    pub fn has_legacy_relay_session_id(&self) -> bool {
        self.legacy_relay_session_id.is_some()
    }

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

    // optional fixed32 from_relay_session_id = 2;

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

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

    pub fn has_from_relay_session_id(&self) -> bool {
        self.from_relay_session_id.is_some()
    }

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

    // optional fixed32 from_connection_id = 7;

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

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

    pub fn has_from_connection_id(&self) -> bool {
        self.from_connection_id.is_some()
    }

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

    // optional fixed64 kludge_pad = 99;

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

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

    pub fn has_kludge_pad(&self) -> bool {
        self.kludge_pad.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.legacy_relay_session_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                21 => {
                    self.from_relay_session_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                61 => {
                    self.from_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                793 => {
                    self.kludge_pad = ::std::option::Option::Some(is.read_fixed64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.legacy_relay_session_id {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.from_relay_session_id {
            os.write_fixed32(2, v)?;
        }
        if let Some(v) = self.from_connection_id {
            os.write_fixed32(7, v)?;
        }
        if let Some(v) = self.kludge_pad {
            os.write_fixed64(99, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.legacy_relay_session_id = ::std::option::Option::None;
        self.from_relay_session_id = ::std::option::Option::None;
        self.from_connection_id = ::std::option::Option::None;
        self.kludge_pad = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramNoSessionRelayToPeer {
        static instance: CMsgSteamDatagramNoSessionRelayToPeer = CMsgSteamDatagramNoSessionRelayToPeer {
            legacy_relay_session_id: ::std::option::Option::None,
            from_relay_session_id: ::std::option::Option::None,
            from_connection_id: ::std::option::Option::None,
            kludge_pad: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgTOSTreatment)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgTOSTreatment {
    // message fields
    // @@protoc_insertion_point(field:CMsgTOSTreatment.l4s_detect)
    pub l4s_detect: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgTOSTreatment.up_ecn1)
    pub up_ecn1: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgTOSTreatment.down_dscp45)
    pub down_dscp45: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgTOSTreatment.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string l4s_detect = 1;

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

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

    pub fn has_l4s_detect(&self) -> bool {
        self.l4s_detect.is_some()
    }

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

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

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

    // optional string up_ecn1 = 2;

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

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

    pub fn has_up_ecn1(&self) -> bool {
        self.up_ecn1.is_some()
    }

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

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

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

    // optional string down_dscp45 = 3;

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

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

    pub fn has_down_dscp45(&self) -> bool {
        self.down_dscp45.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional fixed32 connection_id = 1;

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

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

    pub fn has_connection_id(&self) -> bool {
        self.connection_id.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

// @@protoc_insertion_point(message:CMsgSteamDatagramClientPingSampleReply)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramClientPingSampleReply {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.connection_id)
    pub connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.relay_override_active)
    pub relay_override_active: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.tos)
    pub tos: ::steam_vent_proto_common::protobuf::MessageField<CMsgTOSTreatment>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.pops)
    pub pops: ::std::vec::Vec<cmsg_steam_datagram_client_ping_sample_reply::POP>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.legacy_data_centers)
    pub legacy_data_centers: ::std::vec::Vec<cmsg_steam_datagram_client_ping_sample_reply::LegacyDataCenter>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramClientPingSampleReply.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed32 connection_id = 1;

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

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

    pub fn has_connection_id(&self) -> bool {
        self.connection_id.is_some()
    }

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

    // optional bool relay_override_active = 5;

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

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

    pub fn has_relay_override_active(&self) -> bool {
        self.relay_override_active.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                13 => {
                    self.connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                40 => {
                    self.relay_override_active = ::std::option::Option::Some(is.read_bool()?);
                },
                50 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.tos)?;
                },
                18 => {
                    self.pops.push(is.read_message()?);
                },
                26 => {
                    self.legacy_data_centers.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.connection_id {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.relay_override_active {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.tos.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        }
        for v in &self.pops {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        for v in &self.legacy_data_centers {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.connection_id = ::std::option::Option::None;
        self.relay_override_active = ::std::option::Option::None;
        self.tos.clear();
        self.pops.clear();
        self.legacy_data_centers.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramClientPingSampleReply {
        static instance: CMsgSteamDatagramClientPingSampleReply = CMsgSteamDatagramClientPingSampleReply {
            connection_id: ::std::option::Option::None,
            relay_override_active: ::std::option::Option::None,
            tos: ::steam_vent_proto_common::protobuf::MessageField::none(),
            pops: ::std::vec::Vec::new(),
            legacy_data_centers: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CMsgSteamDatagramClientPingSampleReply`
pub mod cmsg_steam_datagram_client_ping_sample_reply {
    // @@protoc_insertion_point(message:CMsgSteamDatagramClientPingSampleReply.POP)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct POP {
        // message fields
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.pop_id)
        pub pop_id: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.default_front_ping_ms)
        pub default_front_ping_ms: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.cluster_penalty)
        pub cluster_penalty: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.alt_addresses)
        pub alt_addresses: ::std::vec::Vec<pop::AltAddress>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.default_e2e_ping_ms)
        pub default_e2e_ping_ms: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.default_e2e_score)
        pub default_e2e_score: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.p2p_via_peer_relay_pop_id)
        pub p2p_via_peer_relay_pop_id: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.best_dc_ping_ms)
        pub best_dc_ping_ms: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.best_dc_score)
        pub best_dc_score: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.best_dc_via_relay_pop_id)
        pub best_dc_via_relay_pop_id: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.default_dc_ping_ms)
        pub default_dc_ping_ms: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.default_dc_score)
        pub default_dc_score: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.default_dc_via_relay_pop_id)
        pub default_dc_via_relay_pop_id: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.test_dc_ping_ms)
        pub test_dc_ping_ms: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.test_dc_score)
        pub test_dc_score: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.test_dc_via_relay_pop_id)
        pub test_dc_via_relay_pop_id: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CMsgSteamDatagramClientPingSampleReply.POP.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional fixed32 pop_id = 1;

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

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

        pub fn has_pop_id(&self) -> bool {
            self.pop_id.is_some()
        }

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

        // optional uint32 default_front_ping_ms = 2;

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

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

        pub fn has_default_front_ping_ms(&self) -> bool {
            self.default_front_ping_ms.is_some()
        }

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

        // optional uint32 cluster_penalty = 4;

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

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

        pub fn has_cluster_penalty(&self) -> bool {
            self.cluster_penalty.is_some()
        }

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

        // optional uint32 default_e2e_ping_ms = 3;

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

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

        pub fn has_default_e2e_ping_ms(&self) -> bool {
            self.default_e2e_ping_ms.is_some()
        }

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

        // optional uint32 default_e2e_score = 5;

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

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

        pub fn has_default_e2e_score(&self) -> bool {
            self.default_e2e_score.is_some()
        }

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

        // optional fixed32 p2p_via_peer_relay_pop_id = 6;

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

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

        pub fn has_p2p_via_peer_relay_pop_id(&self) -> bool {
            self.p2p_via_peer_relay_pop_id.is_some()
        }

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

        // optional uint32 best_dc_ping_ms = 9;

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

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

        pub fn has_best_dc_ping_ms(&self) -> bool {
            self.best_dc_ping_ms.is_some()
        }

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

        // optional uint32 best_dc_score = 10;

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

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

        pub fn has_best_dc_score(&self) -> bool {
            self.best_dc_score.is_some()
        }

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

        // optional fixed32 best_dc_via_relay_pop_id = 11;

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

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

        pub fn has_best_dc_via_relay_pop_id(&self) -> bool {
            self.best_dc_via_relay_pop_id.is_some()
        }

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

        // optional uint32 default_dc_ping_ms = 12;

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

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

        pub fn has_default_dc_ping_ms(&self) -> bool {
            self.default_dc_ping_ms.is_some()
        }

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

        // optional uint32 default_dc_score = 13;

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

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

        pub fn has_default_dc_score(&self) -> bool {
            self.default_dc_score.is_some()
        }

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

        // optional fixed32 default_dc_via_relay_pop_id = 14;

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

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

        pub fn has_default_dc_via_relay_pop_id(&self) -> bool {
            self.default_dc_via_relay_pop_id.is_some()
        }

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

        // optional uint32 test_dc_ping_ms = 15;

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

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

        pub fn has_test_dc_ping_ms(&self) -> bool {
            self.test_dc_ping_ms.is_some()
        }

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

        // optional uint32 test_dc_score = 16;

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

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

        pub fn has_test_dc_score(&self) -> bool {
            self.test_dc_score.is_some()
        }

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

        // optional fixed32 test_dc_via_relay_pop_id = 17;

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

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

        pub fn has_test_dc_via_relay_pop_id(&self) -> bool {
            self.test_dc_via_relay_pop_id.is_some()
        }

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

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

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

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    13 => {
                        self.pop_id = ::std::option::Option::Some(is.read_fixed32()?);
                    },
                    16 => {
                        self.default_front_ping_ms = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    32 => {
                        self.cluster_penalty = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    58 => {
                        self.alt_addresses.push(is.read_message()?);
                    },
                    24 => {
                        self.default_e2e_ping_ms = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    40 => {
                        self.default_e2e_score = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    53 => {
                        self.p2p_via_peer_relay_pop_id = ::std::option::Option::Some(is.read_fixed32()?);
                    },
                    72 => {
                        self.best_dc_ping_ms = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    80 => {
                        self.best_dc_score = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    93 => {
                        self.best_dc_via_relay_pop_id = ::std::option::Option::Some(is.read_fixed32()?);
                    },
                    96 => {
                        self.default_dc_ping_ms = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    104 => {
                        self.default_dc_score = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    117 => {
                        self.default_dc_via_relay_pop_id = ::std::option::Option::Some(is.read_fixed32()?);
                    },
                    120 => {
                        self.test_dc_ping_ms = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    128 => {
                        self.test_dc_score = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    141 => {
                        self.test_dc_via_relay_pop_id = ::std::option::Option::Some(is.read_fixed32()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if let Some(v) = self.pop_id {
                my_size += 1 + 4;
            }
            if let Some(v) = self.default_front_ping_ms {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
            }
            if let Some(v) = self.cluster_penalty {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
            }
            for value in &self.alt_addresses {
                let len = value.compute_size();
                my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            if let Some(v) = self.default_e2e_ping_ms {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
            }
            if let Some(v) = self.default_e2e_score {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
            }
            if let Some(v) = self.p2p_via_peer_relay_pop_id {
                my_size += 1 + 4;
            }
            if let Some(v) = self.best_dc_ping_ms {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
            }
            if let Some(v) = self.best_dc_score {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(10, v);
            }
            if let Some(v) = self.best_dc_via_relay_pop_id {
                my_size += 1 + 4;
            }
            if let Some(v) = self.default_dc_ping_ms {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(12, v);
            }
            if let Some(v) = self.default_dc_score {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(13, v);
            }
            if let Some(v) = self.default_dc_via_relay_pop_id {
                my_size += 1 + 4;
            }
            if let Some(v) = self.test_dc_ping_ms {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(15, v);
            }
            if let Some(v) = self.test_dc_score {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(16, v);
            }
            if let Some(v) = self.test_dc_via_relay_pop_id {
                my_size += 2 + 4;
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.pop_id {
                os.write_fixed32(1, v)?;
            }
            if let Some(v) = self.default_front_ping_ms {
                os.write_uint32(2, v)?;
            }
            if let Some(v) = self.cluster_penalty {
                os.write_uint32(4, v)?;
            }
            for v in &self.alt_addresses {
                ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
            };
            if let Some(v) = self.default_e2e_ping_ms {
                os.write_uint32(3, v)?;
            }
            if let Some(v) = self.default_e2e_score {
                os.write_uint32(5, v)?;
            }
            if let Some(v) = self.p2p_via_peer_relay_pop_id {
                os.write_fixed32(6, v)?;
            }
            if let Some(v) = self.best_dc_ping_ms {
                os.write_uint32(9, v)?;
            }
            if let Some(v) = self.best_dc_score {
                os.write_uint32(10, v)?;
            }
            if let Some(v) = self.best_dc_via_relay_pop_id {
                os.write_fixed32(11, v)?;
            }
            if let Some(v) = self.default_dc_ping_ms {
                os.write_uint32(12, v)?;
            }
            if let Some(v) = self.default_dc_score {
                os.write_uint32(13, v)?;
            }
            if let Some(v) = self.default_dc_via_relay_pop_id {
                os.write_fixed32(14, v)?;
            }
            if let Some(v) = self.test_dc_ping_ms {
                os.write_uint32(15, v)?;
            }
            if let Some(v) = self.test_dc_score {
                os.write_uint32(16, v)?;
            }
            if let Some(v) = self.test_dc_via_relay_pop_id {
                os.write_fixed32(17, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

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

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

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

        fn clear(&mut self) {
            self.pop_id = ::std::option::Option::None;
            self.default_front_ping_ms = ::std::option::Option::None;
            self.cluster_penalty = ::std::option::Option::None;
            self.alt_addresses.clear();
            self.default_e2e_ping_ms = ::std::option::Option::None;
            self.default_e2e_score = ::std::option::Option::None;
            self.p2p_via_peer_relay_pop_id = ::std::option::Option::None;
            self.best_dc_ping_ms = ::std::option::Option::None;
            self.best_dc_score = ::std::option::Option::None;
            self.best_dc_via_relay_pop_id = ::std::option::Option::None;
            self.default_dc_ping_ms = ::std::option::Option::None;
            self.default_dc_score = ::std::option::Option::None;
            self.default_dc_via_relay_pop_id = ::std::option::Option::None;
            self.test_dc_ping_ms = ::std::option::Option::None;
            self.test_dc_score = ::std::option::Option::None;
            self.test_dc_via_relay_pop_id = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static POP {
            static instance: POP = POP {
                pop_id: ::std::option::Option::None,
                default_front_ping_ms: ::std::option::Option::None,
                cluster_penalty: ::std::option::Option::None,
                alt_addresses: ::std::vec::Vec::new(),
                default_e2e_ping_ms: ::std::option::Option::None,
                default_e2e_score: ::std::option::Option::None,
                p2p_via_peer_relay_pop_id: ::std::option::Option::None,
                best_dc_ping_ms: ::std::option::Option::None,
                best_dc_score: ::std::option::Option::None,
                best_dc_via_relay_pop_id: ::std::option::Option::None,
                default_dc_ping_ms: ::std::option::Option::None,
                default_dc_score: ::std::option::Option::None,
                default_dc_via_relay_pop_id: ::std::option::Option::None,
                test_dc_ping_ms: ::std::option::Option::None,
                test_dc_score: ::std::option::Option::None,
                test_dc_via_relay_pop_id: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `POP`
    pub mod pop {
        // @@protoc_insertion_point(message:CMsgSteamDatagramClientPingSampleReply.POP.AltAddress)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct AltAddress {
            // message fields
            // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.AltAddress.id)
            pub id: ::std::option::Option<::std::string::String>,
            // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.AltAddress.front_ping_ms)
            pub front_ping_ms: ::std::option::Option<u32>,
            // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.POP.AltAddress.penalty)
            pub penalty: ::std::option::Option<u32>,
            // special fields
            // @@protoc_insertion_point(special_field:CMsgSteamDatagramClientPingSampleReply.POP.AltAddress.special_fields)
            pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
        }

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

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

            // optional string id = 1;

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

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

            pub fn has_id(&self) -> bool {
                self.id.is_some()
            }

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

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

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

            // optional uint32 front_ping_ms = 2;

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

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

            pub fn has_front_ping_ms(&self) -> bool {
                self.front_ping_ms.is_some()
            }

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

            // optional uint32 penalty = 3;

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

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

            pub fn has_penalty(&self) -> bool {
                self.penalty.is_some()
            }

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

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

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

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

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

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

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

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

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

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

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

    // @@protoc_insertion_point(message:CMsgSteamDatagramClientPingSampleReply.LegacyDataCenter)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct LegacyDataCenter {
        // message fields
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.LegacyDataCenter.data_center_id)
        pub data_center_id: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.LegacyDataCenter.best_dc_via_relay_pop_id)
        pub best_dc_via_relay_pop_id: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientPingSampleReply.LegacyDataCenter.best_dc_ping_ms)
        pub best_dc_ping_ms: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CMsgSteamDatagramClientPingSampleReply.LegacyDataCenter.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional fixed32 data_center_id = 1;

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

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

        pub fn has_data_center_id(&self) -> bool {
            self.data_center_id.is_some()
        }

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

        // optional fixed32 best_dc_via_relay_pop_id = 2;

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

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

        pub fn has_best_dc_via_relay_pop_id(&self) -> bool {
            self.best_dc_via_relay_pop_id.is_some()
        }

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

        // optional uint32 best_dc_ping_ms = 3;

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

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

        pub fn has_best_dc_ping_ms(&self) -> bool {
            self.best_dc_ping_ms.is_some()
        }

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

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

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

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    13 => {
                        self.data_center_id = ::std::option::Option::Some(is.read_fixed32()?);
                    },
                    21 => {
                        self.best_dc_via_relay_pop_id = ::std::option::Option::Some(is.read_fixed32()?);
                    },
                    24 => {
                        self.best_dc_ping_ms = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

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

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

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

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

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

// @@protoc_insertion_point(message:CMsgSteamDatagramClientSwitchedPrimary)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramClientSwitchedPrimary {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.connection_id)
    pub connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.from_ip)
    pub from_ip: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.from_port)
    pub from_port: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.from_router_cluster)
    pub from_router_cluster: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.from_active_time)
    pub from_active_time: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.from_active_packets_recv)
    pub from_active_packets_recv: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.from_dropped_reason)
    pub from_dropped_reason: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.gap_ms)
    pub gap_ms: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.from_quality_now)
    pub from_quality_now: ::steam_vent_proto_common::protobuf::MessageField<cmsg_steam_datagram_client_switched_primary::RouterQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.to_quality_now)
    pub to_quality_now: ::steam_vent_proto_common::protobuf::MessageField<cmsg_steam_datagram_client_switched_primary::RouterQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.from_quality_then)
    pub from_quality_then: ::steam_vent_proto_common::protobuf::MessageField<cmsg_steam_datagram_client_switched_primary::RouterQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.to_quality_then)
    pub to_quality_then: ::steam_vent_proto_common::protobuf::MessageField<cmsg_steam_datagram_client_switched_primary::RouterQuality>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramClientSwitchedPrimary.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed32 connection_id = 1;

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

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

    pub fn has_connection_id(&self) -> bool {
        self.connection_id.is_some()
    }

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

    // optional fixed32 from_ip = 2;

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

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

    pub fn has_from_ip(&self) -> bool {
        self.from_ip.is_some()
    }

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

    // optional uint32 from_port = 3;

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

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

    pub fn has_from_port(&self) -> bool {
        self.from_port.is_some()
    }

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

    // optional fixed32 from_router_cluster = 4;

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

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

    pub fn has_from_router_cluster(&self) -> bool {
        self.from_router_cluster.is_some()
    }

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

    // optional uint32 from_active_time = 5;

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

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

    pub fn has_from_active_time(&self) -> bool {
        self.from_active_time.is_some()
    }

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

    // optional uint32 from_active_packets_recv = 6;

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

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

    pub fn has_from_active_packets_recv(&self) -> bool {
        self.from_active_packets_recv.is_some()
    }

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

    // optional string from_dropped_reason = 7;

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

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

    pub fn has_from_dropped_reason(&self) -> bool {
        self.from_dropped_reason.is_some()
    }

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

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

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

    // optional uint32 gap_ms = 8;

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

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

    pub fn has_gap_ms(&self) -> bool {
        self.gap_ms.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                13 => {
                    self.connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                21 => {
                    self.from_ip = ::std::option::Option::Some(is.read_fixed32()?);
                },
                24 => {
                    self.from_port = ::std::option::Option::Some(is.read_uint32()?);
                },
                37 => {
                    self.from_router_cluster = ::std::option::Option::Some(is.read_fixed32()?);
                },
                40 => {
                    self.from_active_time = ::std::option::Option::Some(is.read_uint32()?);
                },
                48 => {
                    self.from_active_packets_recv = ::std::option::Option::Some(is.read_uint32()?);
                },
                58 => {
                    self.from_dropped_reason = ::std::option::Option::Some(is.read_string()?);
                },
                64 => {
                    self.gap_ms = ::std::option::Option::Some(is.read_uint32()?);
                },
                74 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.from_quality_now)?;
                },
                82 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.to_quality_now)?;
                },
                90 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.from_quality_then)?;
                },
                98 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.to_quality_then)?;
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.from_ip {
            my_size += 1 + 4;
        }
        if let Some(v) = self.from_port {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.from_router_cluster {
            my_size += 1 + 4;
        }
        if let Some(v) = self.from_active_time {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.from_active_packets_recv {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.from_dropped_reason.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
        }
        if let Some(v) = self.gap_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, v);
        }
        if let Some(v) = self.from_quality_now.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.to_quality_now.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.from_quality_then.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.to_quality_then.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.connection_id {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.from_ip {
            os.write_fixed32(2, v)?;
        }
        if let Some(v) = self.from_port {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.from_router_cluster {
            os.write_fixed32(4, v)?;
        }
        if let Some(v) = self.from_active_time {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.from_active_packets_recv {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.from_dropped_reason.as_ref() {
            os.write_string(7, v)?;
        }
        if let Some(v) = self.gap_ms {
            os.write_uint32(8, v)?;
        }
        if let Some(v) = self.from_quality_now.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
        }
        if let Some(v) = self.to_quality_now.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
        }
        if let Some(v) = self.from_quality_then.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(11, v, os)?;
        }
        if let Some(v) = self.to_quality_then.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(12, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.connection_id = ::std::option::Option::None;
        self.from_ip = ::std::option::Option::None;
        self.from_port = ::std::option::Option::None;
        self.from_router_cluster = ::std::option::Option::None;
        self.from_active_time = ::std::option::Option::None;
        self.from_active_packets_recv = ::std::option::Option::None;
        self.from_dropped_reason = ::std::option::Option::None;
        self.gap_ms = ::std::option::Option::None;
        self.from_quality_now.clear();
        self.to_quality_now.clear();
        self.from_quality_then.clear();
        self.to_quality_then.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramClientSwitchedPrimary {
        static instance: CMsgSteamDatagramClientSwitchedPrimary = CMsgSteamDatagramClientSwitchedPrimary {
            connection_id: ::std::option::Option::None,
            from_ip: ::std::option::Option::None,
            from_port: ::std::option::Option::None,
            from_router_cluster: ::std::option::Option::None,
            from_active_time: ::std::option::Option::None,
            from_active_packets_recv: ::std::option::Option::None,
            from_dropped_reason: ::std::option::Option::None,
            gap_ms: ::std::option::Option::None,
            from_quality_now: ::steam_vent_proto_common::protobuf::MessageField::none(),
            to_quality_now: ::steam_vent_proto_common::protobuf::MessageField::none(),
            from_quality_then: ::steam_vent_proto_common::protobuf::MessageField::none(),
            to_quality_then: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CMsgSteamDatagramClientSwitchedPrimary`
pub mod cmsg_steam_datagram_client_switched_primary {
    // @@protoc_insertion_point(message:CMsgSteamDatagramClientSwitchedPrimary.RouterQuality)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct RouterQuality {
        // message fields
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.RouterQuality.score)
        pub score: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.RouterQuality.front_ping)
        pub front_ping: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.RouterQuality.back_ping)
        pub back_ping: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramClientSwitchedPrimary.RouterQuality.seconds_until_down)
        pub seconds_until_down: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CMsgSteamDatagramClientSwitchedPrimary.RouterQuality.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional uint32 score = 1;

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

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

        pub fn has_score(&self) -> bool {
            self.score.is_some()
        }

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

        // optional uint32 front_ping = 2;

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

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

        pub fn has_front_ping(&self) -> bool {
            self.front_ping.is_some()
        }

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

        // optional uint32 back_ping = 3;

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

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

        pub fn has_back_ping(&self) -> bool {
            self.back_ping.is_some()
        }

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

        // optional uint32 seconds_until_down = 4;

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

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

        pub fn has_seconds_until_down(&self) -> bool {
            self.seconds_until_down.is_some()
        }

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

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

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

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

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

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.score {
                os.write_uint32(1, v)?;
            }
            if let Some(v) = self.front_ping {
                os.write_uint32(2, v)?;
            }
            if let Some(v) = self.back_ping {
                os.write_uint32(3, v)?;
            }
            if let Some(v) = self.seconds_until_down {
                os.write_uint32(4, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

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

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

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

        fn clear(&mut self) {
            self.score = ::std::option::Option::None;
            self.front_ping = ::std::option::Option::None;
            self.back_ping = ::std::option::Option::None;
            self.seconds_until_down = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static RouterQuality {
            static instance: RouterQuality = RouterQuality {
                score: ::std::option::Option::None,
                front_ping: ::std::option::Option::None,
                back_ping: ::std::option::Option::None,
                seconds_until_down: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramConnectRequest)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramConnectRequest {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectRequest.connection_id)
    pub connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectRequest.my_timestamp)
    pub my_timestamp: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectRequest.ping_est_ms)
    pub ping_est_ms: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectRequest.virtual_port)
    pub virtual_port: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectRequest.gameserver_relay_session_id)
    pub gameserver_relay_session_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectRequest.crypt)
    pub crypt: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectRequest.cert)
    pub cert: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectRequest.routing_secret)
    pub routing_secret: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectRequest.legacy_client_steam_id)
    pub legacy_client_steam_id: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramConnectRequest.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed32 connection_id = 1;

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

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

    pub fn has_connection_id(&self) -> bool {
        self.connection_id.is_some()
    }

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

    // optional fixed64 my_timestamp = 4;

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

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

    pub fn has_my_timestamp(&self) -> bool {
        self.my_timestamp.is_some()
    }

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

    // optional uint32 ping_est_ms = 5;

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

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

    pub fn has_ping_est_ms(&self) -> bool {
        self.ping_est_ms.is_some()
    }

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

    // optional uint32 virtual_port = 9;

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

    // optional uint32 gameserver_relay_session_id = 2;

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

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

    pub fn has_gameserver_relay_session_id(&self) -> bool {
        self.gameserver_relay_session_id.is_some()
    }

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

    // optional fixed64 routing_secret = 10;

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

    // optional fixed64 legacy_client_steam_id = 3;

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

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

    pub fn has_legacy_client_steam_id(&self) -> bool {
        self.legacy_client_steam_id.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                13 => {
                    self.connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                33 => {
                    self.my_timestamp = ::std::option::Option::Some(is.read_fixed64()?);
                },
                40 => {
                    self.ping_est_ms = ::std::option::Option::Some(is.read_uint32()?);
                },
                72 => {
                    self.virtual_port = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.gameserver_relay_session_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                50 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.crypt)?;
                },
                58 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.cert)?;
                },
                81 => {
                    self.routing_secret = ::std::option::Option::Some(is.read_fixed64()?);
                },
                25 => {
                    self.legacy_client_steam_id = ::std::option::Option::Some(is.read_fixed64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.my_timestamp {
            my_size += 1 + 8;
        }
        if let Some(v) = self.ping_est_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.virtual_port {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
        }
        if let Some(v) = self.gameserver_relay_session_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.crypt.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.cert.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.routing_secret {
            my_size += 1 + 8;
        }
        if let Some(v) = self.legacy_client_steam_id {
            my_size += 1 + 8;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.connection_id {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.my_timestamp {
            os.write_fixed64(4, v)?;
        }
        if let Some(v) = self.ping_est_ms {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.virtual_port {
            os.write_uint32(9, v)?;
        }
        if let Some(v) = self.gameserver_relay_session_id {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.crypt.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        }
        if let Some(v) = self.cert.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
        }
        if let Some(v) = self.routing_secret {
            os.write_fixed64(10, v)?;
        }
        if let Some(v) = self.legacy_client_steam_id {
            os.write_fixed64(3, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.connection_id = ::std::option::Option::None;
        self.my_timestamp = ::std::option::Option::None;
        self.ping_est_ms = ::std::option::Option::None;
        self.virtual_port = ::std::option::Option::None;
        self.gameserver_relay_session_id = ::std::option::Option::None;
        self.crypt.clear();
        self.cert.clear();
        self.routing_secret = ::std::option::Option::None;
        self.legacy_client_steam_id = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramConnectRequest {
        static instance: CMsgSteamDatagramConnectRequest = CMsgSteamDatagramConnectRequest {
            connection_id: ::std::option::Option::None,
            my_timestamp: ::std::option::Option::None,
            ping_est_ms: ::std::option::Option::None,
            virtual_port: ::std::option::Option::None,
            gameserver_relay_session_id: ::std::option::Option::None,
            crypt: ::steam_vent_proto_common::protobuf::MessageField::none(),
            cert: ::steam_vent_proto_common::protobuf::MessageField::none(),
            routing_secret: ::std::option::Option::None,
            legacy_client_steam_id: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramConnectOK)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramConnectOK {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectOK.client_connection_id)
    pub client_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectOK.server_connection_id)
    pub server_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectOK.your_timestamp)
    pub your_timestamp: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectOK.delay_time_usec)
    pub delay_time_usec: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectOK.gameserver_relay_session_id)
    pub gameserver_relay_session_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectOK.crypt)
    pub crypt: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectOK.cert)
    pub cert: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramConnectOK.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed32 client_connection_id = 1;

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

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

    pub fn has_client_connection_id(&self) -> bool {
        self.client_connection_id.is_some()
    }

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

    // optional fixed32 server_connection_id = 7;

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

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

    pub fn has_server_connection_id(&self) -> bool {
        self.server_connection_id.is_some()
    }

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

    // optional fixed64 your_timestamp = 3;

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

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

    pub fn has_your_timestamp(&self) -> bool {
        self.your_timestamp.is_some()
    }

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

    // optional uint32 delay_time_usec = 4;

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

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

    pub fn has_delay_time_usec(&self) -> bool {
        self.delay_time_usec.is_some()
    }

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

    // optional uint32 gameserver_relay_session_id = 2;

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

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

    pub fn has_gameserver_relay_session_id(&self) -> bool {
        self.gameserver_relay_session_id.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                13 => {
                    self.client_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                61 => {
                    self.server_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                25 => {
                    self.your_timestamp = ::std::option::Option::Some(is.read_fixed64()?);
                },
                32 => {
                    self.delay_time_usec = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.gameserver_relay_session_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                42 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.crypt)?;
                },
                50 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.cert)?;
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.client_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.server_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.your_timestamp {
            my_size += 1 + 8;
        }
        if let Some(v) = self.delay_time_usec {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.gameserver_relay_session_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.crypt.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.cert.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.client_connection_id {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.server_connection_id {
            os.write_fixed32(7, v)?;
        }
        if let Some(v) = self.your_timestamp {
            os.write_fixed64(3, v)?;
        }
        if let Some(v) = self.delay_time_usec {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.gameserver_relay_session_id {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.crypt.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        }
        if let Some(v) = self.cert.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.client_connection_id = ::std::option::Option::None;
        self.server_connection_id = ::std::option::Option::None;
        self.your_timestamp = ::std::option::Option::None;
        self.delay_time_usec = ::std::option::Option::None;
        self.gameserver_relay_session_id = ::std::option::Option::None;
        self.crypt.clear();
        self.cert.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramConnectOK {
        static instance: CMsgSteamDatagramConnectOK = CMsgSteamDatagramConnectOK {
            client_connection_id: ::std::option::Option::None,
            server_connection_id: ::std::option::Option::None,
            your_timestamp: ::std::option::Option::None,
            delay_time_usec: ::std::option::Option::None,
            gameserver_relay_session_id: ::std::option::Option::None,
            crypt: ::steam_vent_proto_common::protobuf::MessageField::none(),
            cert: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamNetworkingP2PSDRRoutingSummary)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamNetworkingP2PSDRRoutingSummary {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamNetworkingP2PSDRRoutingSummary.initial_ping)
    pub initial_ping: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamNetworkingP2PSDRRoutingSummary.initial_ping_front_local)
    pub initial_ping_front_local: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamNetworkingP2PSDRRoutingSummary.initial_ping_front_remote)
    pub initial_ping_front_remote: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamNetworkingP2PSDRRoutingSummary.initial_score)
    pub initial_score: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamNetworkingP2PSDRRoutingSummary.initial_pop_local)
    pub initial_pop_local: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamNetworkingP2PSDRRoutingSummary.initial_pop_remote)
    pub initial_pop_remote: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamNetworkingP2PSDRRoutingSummary.best_ping)
    pub best_ping: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamNetworkingP2PSDRRoutingSummary.best_ping_front_local)
    pub best_ping_front_local: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamNetworkingP2PSDRRoutingSummary.best_ping_front_remote)
    pub best_ping_front_remote: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamNetworkingP2PSDRRoutingSummary.best_score)
    pub best_score: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamNetworkingP2PSDRRoutingSummary.best_pop_local)
    pub best_pop_local: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamNetworkingP2PSDRRoutingSummary.best_pop_remote)
    pub best_pop_remote: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamNetworkingP2PSDRRoutingSummary.best_time)
    pub best_time: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamNetworkingP2PSDRRoutingSummary.negotiation_ms)
    pub negotiation_ms: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamNetworkingP2PSDRRoutingSummary.selected_seconds)
    pub selected_seconds: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamNetworkingP2PSDRRoutingSummary.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 initial_ping = 1;

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

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

    pub fn has_initial_ping(&self) -> bool {
        self.initial_ping.is_some()
    }

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

    // optional uint32 initial_ping_front_local = 2;

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

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

    pub fn has_initial_ping_front_local(&self) -> bool {
        self.initial_ping_front_local.is_some()
    }

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

    // optional uint32 initial_ping_front_remote = 3;

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

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

    pub fn has_initial_ping_front_remote(&self) -> bool {
        self.initial_ping_front_remote.is_some()
    }

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

    // optional uint32 initial_score = 4;

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

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

    pub fn has_initial_score(&self) -> bool {
        self.initial_score.is_some()
    }

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

    // optional fixed32 initial_pop_local = 5;

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

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

    pub fn has_initial_pop_local(&self) -> bool {
        self.initial_pop_local.is_some()
    }

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

    // optional fixed32 initial_pop_remote = 6;

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

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

    pub fn has_initial_pop_remote(&self) -> bool {
        self.initial_pop_remote.is_some()
    }

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

    // optional uint32 best_ping = 11;

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

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

    pub fn has_best_ping(&self) -> bool {
        self.best_ping.is_some()
    }

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

    // optional uint32 best_ping_front_local = 12;

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

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

    pub fn has_best_ping_front_local(&self) -> bool {
        self.best_ping_front_local.is_some()
    }

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

    // optional uint32 best_ping_front_remote = 13;

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

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

    pub fn has_best_ping_front_remote(&self) -> bool {
        self.best_ping_front_remote.is_some()
    }

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

    // optional uint32 best_score = 14;

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

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

    pub fn has_best_score(&self) -> bool {
        self.best_score.is_some()
    }

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

    // optional fixed32 best_pop_local = 15;

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

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

    pub fn has_best_pop_local(&self) -> bool {
        self.best_pop_local.is_some()
    }

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

    // optional fixed32 best_pop_remote = 16;

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

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

    pub fn has_best_pop_remote(&self) -> bool {
        self.best_pop_remote.is_some()
    }

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

    // optional uint32 best_time = 17;

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

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

    pub fn has_best_time(&self) -> bool {
        self.best_time.is_some()
    }

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

    // optional uint32 negotiation_ms = 7;

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

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

    pub fn has_negotiation_ms(&self) -> bool {
        self.negotiation_ms.is_some()
    }

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

    // optional uint32 selected_seconds = 8;

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

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

    pub fn has_selected_seconds(&self) -> bool {
        self.selected_seconds.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.initial_ping = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.initial_ping_front_local = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.initial_ping_front_remote = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.initial_score = ::std::option::Option::Some(is.read_uint32()?);
                },
                45 => {
                    self.initial_pop_local = ::std::option::Option::Some(is.read_fixed32()?);
                },
                53 => {
                    self.initial_pop_remote = ::std::option::Option::Some(is.read_fixed32()?);
                },
                88 => {
                    self.best_ping = ::std::option::Option::Some(is.read_uint32()?);
                },
                96 => {
                    self.best_ping_front_local = ::std::option::Option::Some(is.read_uint32()?);
                },
                104 => {
                    self.best_ping_front_remote = ::std::option::Option::Some(is.read_uint32()?);
                },
                112 => {
                    self.best_score = ::std::option::Option::Some(is.read_uint32()?);
                },
                125 => {
                    self.best_pop_local = ::std::option::Option::Some(is.read_fixed32()?);
                },
                133 => {
                    self.best_pop_remote = ::std::option::Option::Some(is.read_fixed32()?);
                },
                136 => {
                    self.best_time = ::std::option::Option::Some(is.read_uint32()?);
                },
                56 => {
                    self.negotiation_ms = ::std::option::Option::Some(is.read_uint32()?);
                },
                64 => {
                    self.selected_seconds = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.initial_ping {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.initial_ping_front_local {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.initial_ping_front_remote {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.initial_score {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.initial_pop_local {
            my_size += 1 + 4;
        }
        if let Some(v) = self.initial_pop_remote {
            my_size += 1 + 4;
        }
        if let Some(v) = self.best_ping {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(11, v);
        }
        if let Some(v) = self.best_ping_front_local {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(12, v);
        }
        if let Some(v) = self.best_ping_front_remote {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(13, v);
        }
        if let Some(v) = self.best_score {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(14, v);
        }
        if let Some(v) = self.best_pop_local {
            my_size += 1 + 4;
        }
        if let Some(v) = self.best_pop_remote {
            my_size += 2 + 4;
        }
        if let Some(v) = self.best_time {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(17, v);
        }
        if let Some(v) = self.negotiation_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.selected_seconds {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.initial_ping {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.initial_ping_front_local {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.initial_ping_front_remote {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.initial_score {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.initial_pop_local {
            os.write_fixed32(5, v)?;
        }
        if let Some(v) = self.initial_pop_remote {
            os.write_fixed32(6, v)?;
        }
        if let Some(v) = self.best_ping {
            os.write_uint32(11, v)?;
        }
        if let Some(v) = self.best_ping_front_local {
            os.write_uint32(12, v)?;
        }
        if let Some(v) = self.best_ping_front_remote {
            os.write_uint32(13, v)?;
        }
        if let Some(v) = self.best_score {
            os.write_uint32(14, v)?;
        }
        if let Some(v) = self.best_pop_local {
            os.write_fixed32(15, v)?;
        }
        if let Some(v) = self.best_pop_remote {
            os.write_fixed32(16, v)?;
        }
        if let Some(v) = self.best_time {
            os.write_uint32(17, v)?;
        }
        if let Some(v) = self.negotiation_ms {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.selected_seconds {
            os.write_uint32(8, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.initial_ping = ::std::option::Option::None;
        self.initial_ping_front_local = ::std::option::Option::None;
        self.initial_ping_front_remote = ::std::option::Option::None;
        self.initial_score = ::std::option::Option::None;
        self.initial_pop_local = ::std::option::Option::None;
        self.initial_pop_remote = ::std::option::Option::None;
        self.best_ping = ::std::option::Option::None;
        self.best_ping_front_local = ::std::option::Option::None;
        self.best_ping_front_remote = ::std::option::Option::None;
        self.best_score = ::std::option::Option::None;
        self.best_pop_local = ::std::option::Option::None;
        self.best_pop_remote = ::std::option::Option::None;
        self.best_time = ::std::option::Option::None;
        self.negotiation_ms = ::std::option::Option::None;
        self.selected_seconds = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamNetworkingP2PSDRRoutingSummary {
        static instance: CMsgSteamNetworkingP2PSDRRoutingSummary = CMsgSteamNetworkingP2PSDRRoutingSummary {
            initial_ping: ::std::option::Option::None,
            initial_ping_front_local: ::std::option::Option::None,
            initial_ping_front_remote: ::std::option::Option::None,
            initial_score: ::std::option::Option::None,
            initial_pop_local: ::std::option::Option::None,
            initial_pop_remote: ::std::option::Option::None,
            best_ping: ::std::option::Option::None,
            best_ping_front_local: ::std::option::Option::None,
            best_ping_front_remote: ::std::option::Option::None,
            best_score: ::std::option::Option::None,
            best_pop_local: ::std::option::Option::None,
            best_pop_remote: ::std::option::Option::None,
            best_time: ::std::option::Option::None,
            negotiation_ms: ::std::option::Option::None,
            selected_seconds: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramP2PRoutingSummary)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramP2PRoutingSummary {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PRoutingSummary.ice)
    pub ice: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamNetworkingICESessionSummary>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PRoutingSummary.sdr)
    pub sdr: ::steam_vent_proto_common::protobuf::MessageField<CMsgSteamNetworkingP2PSDRRoutingSummary>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramP2PRoutingSummary.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

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

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

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

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

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

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

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

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

    fn default_instance() -> &'static CMsgSteamDatagramP2PRoutingSummary {
        static instance: CMsgSteamDatagramP2PRoutingSummary = CMsgSteamDatagramP2PRoutingSummary {
            ice: ::steam_vent_proto_common::protobuf::MessageField::none(),
            sdr: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramConnectionClosed)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramConnectionClosed {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.to_connection_id)
    pub to_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.from_connection_id)
    pub from_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.from_identity_string)
    pub from_identity_string: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.legacy_from_identity_binary)
    pub legacy_from_identity_binary: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.legacy_from_steam_id)
    pub legacy_from_steam_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.legacy_gameserver_relay_session_id)
    pub legacy_gameserver_relay_session_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.to_relay_session_id)
    pub to_relay_session_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.from_relay_session_id)
    pub from_relay_session_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.forward_target_relay_routing_token)
    pub forward_target_relay_routing_token: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.forward_target_revision)
    pub forward_target_revision: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.relay_mode)
    pub relay_mode: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<cmsg_steam_datagram_connection_closed::ERelayMode>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.debug)
    pub debug: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.reason_code)
    pub reason_code: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.routing_secret)
    pub routing_secret: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.not_primary_session)
    pub not_primary_session: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.not_primary_transport)
    pub not_primary_transport: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.relay_override_active)
    pub relay_override_active: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.quality_relay)
    pub quality_relay: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.quality_e2e)
    pub quality_e2e: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionClosed.p2p_routing_summary)
    pub p2p_routing_summary: ::steam_vent_proto_common::protobuf::MessageField<CMsgSteamDatagramP2PRoutingSummary>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramConnectionClosed.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed32 to_connection_id = 7;

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

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

    pub fn has_to_connection_id(&self) -> bool {
        self.to_connection_id.is_some()
    }

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

    // optional fixed32 from_connection_id = 8;

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

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

    pub fn has_from_connection_id(&self) -> bool {
        self.from_connection_id.is_some()
    }

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

    // optional string from_identity_string = 15;

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

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

    pub fn has_from_identity_string(&self) -> bool {
        self.from_identity_string.is_some()
    }

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

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

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

    // optional fixed64 legacy_from_steam_id = 3;

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

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

    pub fn has_legacy_from_steam_id(&self) -> bool {
        self.legacy_from_steam_id.is_some()
    }

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

    // optional uint32 legacy_gameserver_relay_session_id = 2;

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

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

    pub fn has_legacy_gameserver_relay_session_id(&self) -> bool {
        self.legacy_gameserver_relay_session_id.is_some()
    }

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

    // optional fixed32 to_relay_session_id = 9;

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

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

    pub fn has_to_relay_session_id(&self) -> bool {
        self.to_relay_session_id.is_some()
    }

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

    // optional fixed32 from_relay_session_id = 10;

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

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

    pub fn has_from_relay_session_id(&self) -> bool {
        self.from_relay_session_id.is_some()
    }

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

    // optional bytes forward_target_relay_routing_token = 11;

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

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

    pub fn has_forward_target_relay_routing_token(&self) -> bool {
        self.forward_target_relay_routing_token.is_some()
    }

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

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

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

    // optional uint32 forward_target_revision = 12;

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

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

    pub fn has_forward_target_revision(&self) -> bool {
        self.forward_target_revision.is_some()
    }

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

    // optional .CMsgSteamDatagramConnectionClosed.ERelayMode relay_mode = 4;

    pub fn relay_mode(&self) -> cmsg_steam_datagram_connection_closed::ERelayMode {
        match self.relay_mode {
            Some(e) => e.enum_value_or(cmsg_steam_datagram_connection_closed::ERelayMode::None),
            None => cmsg_steam_datagram_connection_closed::ERelayMode::None,
        }
    }

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

    pub fn has_relay_mode(&self) -> bool {
        self.relay_mode.is_some()
    }

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

    // optional string debug = 5;

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

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

    pub fn has_debug(&self) -> bool {
        self.debug.is_some()
    }

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

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

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

    // optional uint32 reason_code = 6;

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

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

    pub fn has_reason_code(&self) -> bool {
        self.reason_code.is_some()
    }

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

    // optional fixed64 routing_secret = 14;

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

    // optional bool not_primary_session = 16;

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

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

    pub fn has_not_primary_session(&self) -> bool {
        self.not_primary_session.is_some()
    }

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

    // optional bool not_primary_transport = 19;

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

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

    pub fn has_not_primary_transport(&self) -> bool {
        self.not_primary_transport.is_some()
    }

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

    // optional bool relay_override_active = 22;

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

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

    pub fn has_relay_override_active(&self) -> bool {
        self.relay_override_active.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                61 => {
                    self.to_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                69 => {
                    self.from_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                122 => {
                    self.from_identity_string = ::std::option::Option::Some(is.read_string()?);
                },
                106 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.legacy_from_identity_binary)?;
                },
                25 => {
                    self.legacy_from_steam_id = ::std::option::Option::Some(is.read_fixed64()?);
                },
                16 => {
                    self.legacy_gameserver_relay_session_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                77 => {
                    self.to_relay_session_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                85 => {
                    self.from_relay_session_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                90 => {
                    self.forward_target_relay_routing_token = ::std::option::Option::Some(is.read_bytes()?);
                },
                96 => {
                    self.forward_target_revision = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.relay_mode = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                42 => {
                    self.debug = ::std::option::Option::Some(is.read_string()?);
                },
                48 => {
                    self.reason_code = ::std::option::Option::Some(is.read_uint32()?);
                },
                113 => {
                    self.routing_secret = ::std::option::Option::Some(is.read_fixed64()?);
                },
                128 => {
                    self.not_primary_session = ::std::option::Option::Some(is.read_bool()?);
                },
                152 => {
                    self.not_primary_transport = ::std::option::Option::Some(is.read_bool()?);
                },
                176 => {
                    self.relay_override_active = ::std::option::Option::Some(is.read_bool()?);
                },
                138 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_relay)?;
                },
                146 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_e2e)?;
                },
                170 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.p2p_routing_summary)?;
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.to_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.from_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.from_identity_string.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(15, &v);
        }
        if let Some(v) = self.legacy_from_identity_binary.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.legacy_from_steam_id {
            my_size += 1 + 8;
        }
        if let Some(v) = self.legacy_gameserver_relay_session_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.to_relay_session_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.from_relay_session_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.forward_target_relay_routing_token.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(11, &v);
        }
        if let Some(v) = self.forward_target_revision {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(12, v);
        }
        if let Some(v) = self.relay_mode {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v.value());
        }
        if let Some(v) = self.debug.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &v);
        }
        if let Some(v) = self.reason_code {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.routing_secret {
            my_size += 1 + 8;
        }
        if let Some(v) = self.not_primary_session {
            my_size += 2 + 1;
        }
        if let Some(v) = self.not_primary_transport {
            my_size += 2 + 1;
        }
        if let Some(v) = self.relay_override_active {
            my_size += 2 + 1;
        }
        if let Some(v) = self.quality_relay.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.p2p_routing_summary.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.to_connection_id {
            os.write_fixed32(7, v)?;
        }
        if let Some(v) = self.from_connection_id {
            os.write_fixed32(8, v)?;
        }
        if let Some(v) = self.from_identity_string.as_ref() {
            os.write_string(15, v)?;
        }
        if let Some(v) = self.legacy_from_identity_binary.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(13, v, os)?;
        }
        if let Some(v) = self.legacy_from_steam_id {
            os.write_fixed64(3, v)?;
        }
        if let Some(v) = self.legacy_gameserver_relay_session_id {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.to_relay_session_id {
            os.write_fixed32(9, v)?;
        }
        if let Some(v) = self.from_relay_session_id {
            os.write_fixed32(10, v)?;
        }
        if let Some(v) = self.forward_target_relay_routing_token.as_ref() {
            os.write_bytes(11, v)?;
        }
        if let Some(v) = self.forward_target_revision {
            os.write_uint32(12, v)?;
        }
        if let Some(v) = self.relay_mode {
            os.write_enum(4, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.debug.as_ref() {
            os.write_string(5, v)?;
        }
        if let Some(v) = self.reason_code {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.routing_secret {
            os.write_fixed64(14, v)?;
        }
        if let Some(v) = self.not_primary_session {
            os.write_bool(16, v)?;
        }
        if let Some(v) = self.not_primary_transport {
            os.write_bool(19, v)?;
        }
        if let Some(v) = self.relay_override_active {
            os.write_bool(22, v)?;
        }
        if let Some(v) = self.quality_relay.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(17, v, os)?;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(18, v, os)?;
        }
        if let Some(v) = self.p2p_routing_summary.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(21, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.to_connection_id = ::std::option::Option::None;
        self.from_connection_id = ::std::option::Option::None;
        self.from_identity_string = ::std::option::Option::None;
        self.legacy_from_identity_binary.clear();
        self.legacy_from_steam_id = ::std::option::Option::None;
        self.legacy_gameserver_relay_session_id = ::std::option::Option::None;
        self.to_relay_session_id = ::std::option::Option::None;
        self.from_relay_session_id = ::std::option::Option::None;
        self.forward_target_relay_routing_token = ::std::option::Option::None;
        self.forward_target_revision = ::std::option::Option::None;
        self.relay_mode = ::std::option::Option::None;
        self.debug = ::std::option::Option::None;
        self.reason_code = ::std::option::Option::None;
        self.routing_secret = ::std::option::Option::None;
        self.not_primary_session = ::std::option::Option::None;
        self.not_primary_transport = ::std::option::Option::None;
        self.relay_override_active = ::std::option::Option::None;
        self.quality_relay.clear();
        self.quality_e2e.clear();
        self.p2p_routing_summary.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramConnectionClosed {
        static instance: CMsgSteamDatagramConnectionClosed = CMsgSteamDatagramConnectionClosed {
            to_connection_id: ::std::option::Option::None,
            from_connection_id: ::std::option::Option::None,
            from_identity_string: ::std::option::Option::None,
            legacy_from_identity_binary: ::steam_vent_proto_common::protobuf::MessageField::none(),
            legacy_from_steam_id: ::std::option::Option::None,
            legacy_gameserver_relay_session_id: ::std::option::Option::None,
            to_relay_session_id: ::std::option::Option::None,
            from_relay_session_id: ::std::option::Option::None,
            forward_target_relay_routing_token: ::std::option::Option::None,
            forward_target_revision: ::std::option::Option::None,
            relay_mode: ::std::option::Option::None,
            debug: ::std::option::Option::None,
            reason_code: ::std::option::Option::None,
            routing_secret: ::std::option::Option::None,
            not_primary_session: ::std::option::Option::None,
            not_primary_transport: ::std::option::Option::None,
            relay_override_active: ::std::option::Option::None,
            quality_relay: ::steam_vent_proto_common::protobuf::MessageField::none(),
            quality_e2e: ::steam_vent_proto_common::protobuf::MessageField::none(),
            p2p_routing_summary: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CMsgSteamDatagramConnectionClosed`
pub mod cmsg_steam_datagram_connection_closed {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    // @@protoc_insertion_point(enum:CMsgSteamDatagramConnectionClosed.ERelayMode)
    pub enum ERelayMode {
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionClosed.ERelayMode.None)
        None = 0,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionClosed.ERelayMode.EndToEnd)
        EndToEnd = 1,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionClosed.ERelayMode.ClosedByPeer)
        ClosedByPeer = 2,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<ERelayMode> {
            match value {
                0 => ::std::option::Option::Some(ERelayMode::None),
                1 => ::std::option::Option::Some(ERelayMode::EndToEnd),
                2 => ::std::option::Option::Some(ERelayMode::ClosedByPeer),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<ERelayMode> {
            match str {
                "None" => ::std::option::Option::Some(ERelayMode::None),
                "EndToEnd" => ::std::option::Option::Some(ERelayMode::EndToEnd),
                "ClosedByPeer" => ::std::option::Option::Some(ERelayMode::ClosedByPeer),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [ERelayMode] = &[
            ERelayMode::None,
            ERelayMode::EndToEnd,
            ERelayMode::ClosedByPeer,
        ];
    }

    impl ::std::default::Default for ERelayMode {
        fn default() -> Self {
            ERelayMode::None
        }
    }

}

// @@protoc_insertion_point(message:CMsgSteamDatagramNoConnection)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramNoConnection {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.to_connection_id)
    pub to_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.from_connection_id)
    pub from_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.legacy_gameserver_relay_session_id)
    pub legacy_gameserver_relay_session_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.to_relay_session_id)
    pub to_relay_session_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.from_relay_session_id)
    pub from_relay_session_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.from_identity_string)
    pub from_identity_string: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.legacy_from_steam_id)
    pub legacy_from_steam_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.end_to_end)
    pub end_to_end: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.not_primary_session)
    pub not_primary_session: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.not_primary_transport)
    pub not_primary_transport: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.relay_override_active)
    pub relay_override_active: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.quality_relay)
    pub quality_relay: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.quality_e2e)
    pub quality_e2e: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.p2p_routing_summary)
    pub p2p_routing_summary: ::steam_vent_proto_common::protobuf::MessageField<CMsgSteamDatagramP2PRoutingSummary>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.routing_secret)
    pub routing_secret: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramNoConnection.dummy_pad)
    pub dummy_pad: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramNoConnection.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed32 to_connection_id = 5;

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

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

    pub fn has_to_connection_id(&self) -> bool {
        self.to_connection_id.is_some()
    }

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

    // optional fixed32 from_connection_id = 6;

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

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

    pub fn has_from_connection_id(&self) -> bool {
        self.from_connection_id.is_some()
    }

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

    // optional uint32 legacy_gameserver_relay_session_id = 2;

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

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

    pub fn has_legacy_gameserver_relay_session_id(&self) -> bool {
        self.legacy_gameserver_relay_session_id.is_some()
    }

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

    // optional fixed32 to_relay_session_id = 9;

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

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

    pub fn has_to_relay_session_id(&self) -> bool {
        self.to_relay_session_id.is_some()
    }

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

    // optional fixed32 from_relay_session_id = 10;

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

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

    pub fn has_from_relay_session_id(&self) -> bool {
        self.from_relay_session_id.is_some()
    }

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

    // optional string from_identity_string = 7;

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

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

    pub fn has_from_identity_string(&self) -> bool {
        self.from_identity_string.is_some()
    }

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

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

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

    // optional fixed64 legacy_from_steam_id = 3;

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

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

    pub fn has_legacy_from_steam_id(&self) -> bool {
        self.legacy_from_steam_id.is_some()
    }

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

    // optional bool end_to_end = 4;

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

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

    pub fn has_end_to_end(&self) -> bool {
        self.end_to_end.is_some()
    }

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

    // optional bool not_primary_session = 12;

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

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

    pub fn has_not_primary_session(&self) -> bool {
        self.not_primary_session.is_some()
    }

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

    // optional bool not_primary_transport = 15;

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

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

    pub fn has_not_primary_transport(&self) -> bool {
        self.not_primary_transport.is_some()
    }

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

    // optional bool relay_override_active = 17;

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

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

    pub fn has_relay_override_active(&self) -> bool {
        self.relay_override_active.is_some()
    }

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

    // optional fixed64 routing_secret = 11;

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

    // optional fixed32 dummy_pad = 1023;

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

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

    pub fn has_dummy_pad(&self) -> bool {
        self.dummy_pad.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                45 => {
                    self.to_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                53 => {
                    self.from_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                16 => {
                    self.legacy_gameserver_relay_session_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                77 => {
                    self.to_relay_session_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                85 => {
                    self.from_relay_session_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                58 => {
                    self.from_identity_string = ::std::option::Option::Some(is.read_string()?);
                },
                25 => {
                    self.legacy_from_steam_id = ::std::option::Option::Some(is.read_fixed64()?);
                },
                32 => {
                    self.end_to_end = ::std::option::Option::Some(is.read_bool()?);
                },
                96 => {
                    self.not_primary_session = ::std::option::Option::Some(is.read_bool()?);
                },
                120 => {
                    self.not_primary_transport = ::std::option::Option::Some(is.read_bool()?);
                },
                136 => {
                    self.relay_override_active = ::std::option::Option::Some(is.read_bool()?);
                },
                106 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_relay)?;
                },
                114 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_e2e)?;
                },
                130 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.p2p_routing_summary)?;
                },
                89 => {
                    self.routing_secret = ::std::option::Option::Some(is.read_fixed64()?);
                },
                8189 => {
                    self.dummy_pad = ::std::option::Option::Some(is.read_fixed32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.to_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.from_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.legacy_gameserver_relay_session_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.to_relay_session_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.from_relay_session_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.from_identity_string.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
        }
        if let Some(v) = self.legacy_from_steam_id {
            my_size += 1 + 8;
        }
        if let Some(v) = self.end_to_end {
            my_size += 1 + 1;
        }
        if let Some(v) = self.not_primary_session {
            my_size += 1 + 1;
        }
        if let Some(v) = self.not_primary_transport {
            my_size += 1 + 1;
        }
        if let Some(v) = self.relay_override_active {
            my_size += 2 + 1;
        }
        if let Some(v) = self.quality_relay.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.p2p_routing_summary.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.routing_secret {
            my_size += 1 + 8;
        }
        if let Some(v) = self.dummy_pad {
            my_size += 2 + 4;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.to_connection_id {
            os.write_fixed32(5, v)?;
        }
        if let Some(v) = self.from_connection_id {
            os.write_fixed32(6, v)?;
        }
        if let Some(v) = self.legacy_gameserver_relay_session_id {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.to_relay_session_id {
            os.write_fixed32(9, v)?;
        }
        if let Some(v) = self.from_relay_session_id {
            os.write_fixed32(10, v)?;
        }
        if let Some(v) = self.from_identity_string.as_ref() {
            os.write_string(7, v)?;
        }
        if let Some(v) = self.legacy_from_steam_id {
            os.write_fixed64(3, v)?;
        }
        if let Some(v) = self.end_to_end {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.not_primary_session {
            os.write_bool(12, v)?;
        }
        if let Some(v) = self.not_primary_transport {
            os.write_bool(15, v)?;
        }
        if let Some(v) = self.relay_override_active {
            os.write_bool(17, v)?;
        }
        if let Some(v) = self.quality_relay.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(13, v, os)?;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(14, v, os)?;
        }
        if let Some(v) = self.p2p_routing_summary.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(16, v, os)?;
        }
        if let Some(v) = self.routing_secret {
            os.write_fixed64(11, v)?;
        }
        if let Some(v) = self.dummy_pad {
            os.write_fixed32(1023, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.to_connection_id = ::std::option::Option::None;
        self.from_connection_id = ::std::option::Option::None;
        self.legacy_gameserver_relay_session_id = ::std::option::Option::None;
        self.to_relay_session_id = ::std::option::Option::None;
        self.from_relay_session_id = ::std::option::Option::None;
        self.from_identity_string = ::std::option::Option::None;
        self.legacy_from_steam_id = ::std::option::Option::None;
        self.end_to_end = ::std::option::Option::None;
        self.not_primary_session = ::std::option::Option::None;
        self.not_primary_transport = ::std::option::Option::None;
        self.relay_override_active = ::std::option::Option::None;
        self.quality_relay.clear();
        self.quality_e2e.clear();
        self.p2p_routing_summary.clear();
        self.routing_secret = ::std::option::Option::None;
        self.dummy_pad = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramNoConnection {
        static instance: CMsgSteamDatagramNoConnection = CMsgSteamDatagramNoConnection {
            to_connection_id: ::std::option::Option::None,
            from_connection_id: ::std::option::Option::None,
            legacy_gameserver_relay_session_id: ::std::option::Option::None,
            to_relay_session_id: ::std::option::Option::None,
            from_relay_session_id: ::std::option::Option::None,
            from_identity_string: ::std::option::Option::None,
            legacy_from_steam_id: ::std::option::Option::None,
            end_to_end: ::std::option::Option::None,
            not_primary_session: ::std::option::Option::None,
            not_primary_transport: ::std::option::Option::None,
            relay_override_active: ::std::option::Option::None,
            quality_relay: ::steam_vent_proto_common::protobuf::MessageField::none(),
            quality_e2e: ::steam_vent_proto_common::protobuf::MessageField::none(),
            p2p_routing_summary: ::steam_vent_proto_common::protobuf::MessageField::none(),
            routing_secret: ::std::option::Option::None,
            dummy_pad: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramGameserverSessionRequest)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramGameserverSessionRequest {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionRequest.ticket)
    pub ticket: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionRequest.challenge_time)
    pub challenge_time: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionRequest.challenge)
    pub challenge: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionRequest.client_connection_id)
    pub client_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionRequest.server_connection_id)
    pub server_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionRequest.network_config_version)
    pub network_config_version: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionRequest.protocol_version)
    pub protocol_version: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionRequest.platform)
    pub platform: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionRequest.build)
    pub build: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionRequest.dev_gameserver_identity)
    pub dev_gameserver_identity: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionRequest.dev_client_cert)
    pub dev_client_cert: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramGameserverSessionRequest.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional bytes ticket = 1;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_ticket(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.ticket.is_none() {
            self.ticket = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        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 fixed32 challenge_time = 3;

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

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

    pub fn has_challenge_time(&self) -> bool {
        self.challenge_time.is_some()
    }

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

    // optional fixed64 challenge = 4;

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

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

    pub fn has_challenge(&self) -> bool {
        self.challenge.is_some()
    }

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

    // optional fixed32 client_connection_id = 5;

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

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

    pub fn has_client_connection_id(&self) -> bool {
        self.client_connection_id.is_some()
    }

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

    // optional fixed32 server_connection_id = 8;

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

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

    pub fn has_server_connection_id(&self) -> bool {
        self.server_connection_id.is_some()
    }

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

    // optional uint64 network_config_version = 6;

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

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

    pub fn has_network_config_version(&self) -> bool {
        self.network_config_version.is_some()
    }

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

    // optional uint32 protocol_version = 7;

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

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

    pub fn has_protocol_version(&self) -> bool {
        self.protocol_version.is_some()
    }

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

    // optional string platform = 9;

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

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

    pub fn has_platform(&self) -> bool {
        self.platform.is_some()
    }

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

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

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

    // optional string build = 10;

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

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

    pub fn has_build(&self) -> bool {
        self.build.is_some()
    }

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

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

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

    // optional string dev_gameserver_identity = 100;

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

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

    pub fn has_dev_gameserver_identity(&self) -> bool {
        self.dev_gameserver_identity.is_some()
    }

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.ticket = ::std::option::Option::Some(is.read_bytes()?);
                },
                29 => {
                    self.challenge_time = ::std::option::Option::Some(is.read_fixed32()?);
                },
                33 => {
                    self.challenge = ::std::option::Option::Some(is.read_fixed64()?);
                },
                45 => {
                    self.client_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                69 => {
                    self.server_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                48 => {
                    self.network_config_version = ::std::option::Option::Some(is.read_uint64()?);
                },
                56 => {
                    self.protocol_version = ::std::option::Option::Some(is.read_uint32()?);
                },
                74 => {
                    self.platform = ::std::option::Option::Some(is.read_string()?);
                },
                82 => {
                    self.build = ::std::option::Option::Some(is.read_string()?);
                },
                802 => {
                    self.dev_gameserver_identity = ::std::option::Option::Some(is.read_string()?);
                },
                810 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.dev_client_cert)?;
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.ticket.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(v) = self.challenge_time {
            my_size += 1 + 4;
        }
        if let Some(v) = self.challenge {
            my_size += 1 + 8;
        }
        if let Some(v) = self.client_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.server_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.network_config_version {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(6, v);
        }
        if let Some(v) = self.protocol_version {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.platform.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &v);
        }
        if let Some(v) = self.build.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(10, &v);
        }
        if let Some(v) = self.dev_gameserver_identity.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(100, &v);
        }
        if let Some(v) = self.dev_client_cert.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.ticket.as_ref() {
            os.write_bytes(1, v)?;
        }
        if let Some(v) = self.challenge_time {
            os.write_fixed32(3, v)?;
        }
        if let Some(v) = self.challenge {
            os.write_fixed64(4, v)?;
        }
        if let Some(v) = self.client_connection_id {
            os.write_fixed32(5, v)?;
        }
        if let Some(v) = self.server_connection_id {
            os.write_fixed32(8, v)?;
        }
        if let Some(v) = self.network_config_version {
            os.write_uint64(6, v)?;
        }
        if let Some(v) = self.protocol_version {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.platform.as_ref() {
            os.write_string(9, v)?;
        }
        if let Some(v) = self.build.as_ref() {
            os.write_string(10, v)?;
        }
        if let Some(v) = self.dev_gameserver_identity.as_ref() {
            os.write_string(100, v)?;
        }
        if let Some(v) = self.dev_client_cert.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(101, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.ticket = ::std::option::Option::None;
        self.challenge_time = ::std::option::Option::None;
        self.challenge = ::std::option::Option::None;
        self.client_connection_id = ::std::option::Option::None;
        self.server_connection_id = ::std::option::Option::None;
        self.network_config_version = ::std::option::Option::None;
        self.protocol_version = ::std::option::Option::None;
        self.platform = ::std::option::Option::None;
        self.build = ::std::option::Option::None;
        self.dev_gameserver_identity = ::std::option::Option::None;
        self.dev_client_cert.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramGameserverSessionRequest {
        static instance: CMsgSteamDatagramGameserverSessionRequest = CMsgSteamDatagramGameserverSessionRequest {
            ticket: ::std::option::Option::None,
            challenge_time: ::std::option::Option::None,
            challenge: ::std::option::Option::None,
            client_connection_id: ::std::option::Option::None,
            server_connection_id: ::std::option::Option::None,
            network_config_version: ::std::option::Option::None,
            protocol_version: ::std::option::Option::None,
            platform: ::std::option::Option::None,
            build: ::std::option::Option::None,
            dev_gameserver_identity: ::std::option::Option::None,
            dev_client_cert: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramGameserverSessionEstablished)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramGameserverSessionEstablished {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionEstablished.connection_id)
    pub connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionEstablished.gameserver_identity_string)
    pub gameserver_identity_string: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionEstablished.seconds_until_shutdown)
    pub seconds_until_shutdown: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionEstablished.seq_num_r2c)
    pub seq_num_r2c: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionEstablished.dummy_legacy_identity_binary)
    pub dummy_legacy_identity_binary: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameserverSessionEstablished.legacy_gameserver_steamid)
    pub legacy_gameserver_steamid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramGameserverSessionEstablished.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed32 connection_id = 1;

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

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

    pub fn has_connection_id(&self) -> bool {
        self.connection_id.is_some()
    }

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

    // optional string gameserver_identity_string = 2;

    pub fn 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 = ::std::option::Option::None;
    }

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_gameserver_identity_string(&mut self) -> &mut ::std::string::String {
        if self.gameserver_identity_string.is_none() {
            self.gameserver_identity_string = ::std::option::Option::Some(::std::string::String::new());
        }
        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 uint32 seconds_until_shutdown = 4;

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

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

    pub fn has_seconds_until_shutdown(&self) -> bool {
        self.seconds_until_shutdown.is_some()
    }

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

    // optional uint32 seq_num_r2c = 6;

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

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

    pub fn has_seq_num_r2c(&self) -> bool {
        self.seq_num_r2c.is_some()
    }

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

    // optional bytes dummy_legacy_identity_binary = 7;

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

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

    pub fn has_dummy_legacy_identity_binary(&self) -> bool {
        self.dummy_legacy_identity_binary.is_some()
    }

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

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

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

    // optional fixed64 legacy_gameserver_steamid = 3;

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

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

    pub fn has_legacy_gameserver_steamid(&self) -> bool {
        self.legacy_gameserver_steamid.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                13 => {
                    self.connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                18 => {
                    self.gameserver_identity_string = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.seconds_until_shutdown = ::std::option::Option::Some(is.read_uint32()?);
                },
                48 => {
                    self.seq_num_r2c = ::std::option::Option::Some(is.read_uint32()?);
                },
                58 => {
                    self.dummy_legacy_identity_binary = ::std::option::Option::Some(is.read_bytes()?);
                },
                25 => {
                    self.legacy_gameserver_steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.gameserver_identity_string.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.seconds_until_shutdown {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.seq_num_r2c {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.dummy_legacy_identity_binary.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(7, &v);
        }
        if let Some(v) = self.legacy_gameserver_steamid {
            my_size += 1 + 8;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.connection_id {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.gameserver_identity_string.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.seconds_until_shutdown {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.seq_num_r2c {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.dummy_legacy_identity_binary.as_ref() {
            os.write_bytes(7, v)?;
        }
        if let Some(v) = self.legacy_gameserver_steamid {
            os.write_fixed64(3, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.connection_id = ::std::option::Option::None;
        self.gameserver_identity_string = ::std::option::Option::None;
        self.seconds_until_shutdown = ::std::option::Option::None;
        self.seq_num_r2c = ::std::option::Option::None;
        self.dummy_legacy_identity_binary = ::std::option::Option::None;
        self.legacy_gameserver_steamid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramGameserverSessionEstablished {
        static instance: CMsgSteamDatagramGameserverSessionEstablished = CMsgSteamDatagramGameserverSessionEstablished {
            connection_id: ::std::option::Option::None,
            gameserver_identity_string: ::std::option::Option::None,
            seconds_until_shutdown: ::std::option::Option::None,
            seq_num_r2c: ::std::option::Option::None,
            dummy_legacy_identity_binary: ::std::option::Option::None,
            legacy_gameserver_steamid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramConnectionStatsClientToRouter)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramConnectionStatsClientToRouter {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsClientToRouter.quality_relay)
    pub quality_relay: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsClientToRouter.quality_e2e)
    pub quality_e2e: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsClientToRouter.ack_relay)
    pub ack_relay: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsClientToRouter.legacy_ack_e2e)
    pub legacy_ack_e2e: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsClientToRouter.flags)
    pub flags: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsClientToRouter.client_connection_id)
    pub client_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsClientToRouter.seq_num_c2r)
    pub seq_num_c2r: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsClientToRouter.seq_num_e2e)
    pub seq_num_e2e: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramConnectionStatsClientToRouter.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 flags = 6;

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

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

    pub fn has_flags(&self) -> bool {
        self.flags.is_some()
    }

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

    // optional fixed32 client_connection_id = 8;

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

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

    pub fn has_client_connection_id(&self) -> bool {
        self.client_connection_id.is_some()
    }

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

    // optional uint32 seq_num_c2r = 9;

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

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

    pub fn has_seq_num_c2r(&self) -> bool {
        self.seq_num_c2r.is_some()
    }

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

    // optional uint32 seq_num_e2e = 10;

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

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

    pub fn has_seq_num_e2e(&self) -> bool {
        self.seq_num_e2e.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CMsgSteamDatagramConnectionStatsClientToRouter {
    const NAME: &'static str = "CMsgSteamDatagramConnectionStatsClientToRouter";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_relay)?;
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_e2e)?;
                },
                34 => {
                    is.read_repeated_packed_fixed32_into(&mut self.ack_relay)?;
                },
                37 => {
                    self.ack_relay.push(is.read_fixed32()?);
                },
                42 => {
                    is.read_repeated_packed_fixed32_into(&mut self.legacy_ack_e2e)?;
                },
                45 => {
                    self.legacy_ack_e2e.push(is.read_fixed32()?);
                },
                48 => {
                    self.flags = ::std::option::Option::Some(is.read_uint32()?);
                },
                69 => {
                    self.client_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                72 => {
                    self.seq_num_c2r = ::std::option::Option::Some(is.read_uint32()?);
                },
                80 => {
                    self.seq_num_e2e = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.quality_relay.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += 5 * self.ack_relay.len() as u64;
        my_size += 5 * self.legacy_ack_e2e.len() as u64;
        if let Some(v) = self.flags {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.client_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.seq_num_c2r {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
        }
        if let Some(v) = self.seq_num_e2e {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(10, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.quality_relay.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        for v in &self.ack_relay {
            os.write_fixed32(4, *v)?;
        };
        for v in &self.legacy_ack_e2e {
            os.write_fixed32(5, *v)?;
        };
        if let Some(v) = self.flags {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.client_connection_id {
            os.write_fixed32(8, v)?;
        }
        if let Some(v) = self.seq_num_c2r {
            os.write_uint32(9, v)?;
        }
        if let Some(v) = self.seq_num_e2e {
            os.write_uint32(10, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CMsgSteamDatagramConnectionStatsClientToRouter {
        CMsgSteamDatagramConnectionStatsClientToRouter::new()
    }

    fn clear(&mut self) {
        self.quality_relay.clear();
        self.quality_e2e.clear();
        self.ack_relay.clear();
        self.legacy_ack_e2e.clear();
        self.flags = ::std::option::Option::None;
        self.client_connection_id = ::std::option::Option::None;
        self.seq_num_c2r = ::std::option::Option::None;
        self.seq_num_e2e = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramConnectionStatsClientToRouter {
        static instance: CMsgSteamDatagramConnectionStatsClientToRouter = CMsgSteamDatagramConnectionStatsClientToRouter {
            quality_relay: ::steam_vent_proto_common::protobuf::MessageField::none(),
            quality_e2e: ::steam_vent_proto_common::protobuf::MessageField::none(),
            ack_relay: ::std::vec::Vec::new(),
            legacy_ack_e2e: ::std::vec::Vec::new(),
            flags: ::std::option::Option::None,
            client_connection_id: ::std::option::Option::None,
            seq_num_c2r: ::std::option::Option::None,
            seq_num_e2e: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CMsgSteamDatagramConnectionStatsClientToRouter`
pub mod cmsg_steam_datagram_connection_stats_client_to_router {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    // @@protoc_insertion_point(enum:CMsgSteamDatagramConnectionStatsClientToRouter.Flags)
    pub enum Flags {
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsClientToRouter.Flags.ACK_REQUEST_RELAY)
        ACK_REQUEST_RELAY = 1,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsClientToRouter.Flags.ACK_REQUEST_E2E)
        ACK_REQUEST_E2E = 2,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsClientToRouter.Flags.ACK_REQUEST_IMMEDIATE)
        ACK_REQUEST_IMMEDIATE = 4,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsClientToRouter.Flags.NOT_PRIMARY_SESSION)
        NOT_PRIMARY_SESSION = 8,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsClientToRouter.Flags.CLIENT_RELAY_OVERRIDE)
        CLIENT_RELAY_OVERRIDE = 32,
    }

    impl ::steam_vent_proto_common::protobuf::Enum for Flags {
        const NAME: &'static str = "Flags";

        fn value(&self) -> i32 {
            *self as i32
        }

        fn from_i32(value: i32) -> ::std::option::Option<Flags> {
            match value {
                1 => ::std::option::Option::Some(Flags::ACK_REQUEST_RELAY),
                2 => ::std::option::Option::Some(Flags::ACK_REQUEST_E2E),
                4 => ::std::option::Option::Some(Flags::ACK_REQUEST_IMMEDIATE),
                8 => ::std::option::Option::Some(Flags::NOT_PRIMARY_SESSION),
                32 => ::std::option::Option::Some(Flags::CLIENT_RELAY_OVERRIDE),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Flags> {
            match str {
                "ACK_REQUEST_RELAY" => ::std::option::Option::Some(Flags::ACK_REQUEST_RELAY),
                "ACK_REQUEST_E2E" => ::std::option::Option::Some(Flags::ACK_REQUEST_E2E),
                "ACK_REQUEST_IMMEDIATE" => ::std::option::Option::Some(Flags::ACK_REQUEST_IMMEDIATE),
                "NOT_PRIMARY_SESSION" => ::std::option::Option::Some(Flags::NOT_PRIMARY_SESSION),
                "CLIENT_RELAY_OVERRIDE" => ::std::option::Option::Some(Flags::CLIENT_RELAY_OVERRIDE),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Flags] = &[
            Flags::ACK_REQUEST_RELAY,
            Flags::ACK_REQUEST_E2E,
            Flags::ACK_REQUEST_IMMEDIATE,
            Flags::NOT_PRIMARY_SESSION,
            Flags::CLIENT_RELAY_OVERRIDE,
        ];
    }

    // Note, `Default` is implemented although default value is not 0
    impl ::std::default::Default for Flags {
        fn default() -> Self {
            Flags::ACK_REQUEST_RELAY
        }
    }

}

// @@protoc_insertion_point(message:CMsgSteamDatagramConnectionStatsRouterToClient)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramConnectionStatsRouterToClient {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToClient.quality_relay)
    pub quality_relay: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToClient.quality_e2e)
    pub quality_e2e: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToClient.seconds_until_shutdown)
    pub seconds_until_shutdown: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToClient.migrate_request_ip)
    pub migrate_request_ip: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToClient.migrate_request_port)
    pub migrate_request_port: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToClient.scoring_penalty_relay_cluster)
    pub scoring_penalty_relay_cluster: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToClient.ack_relay)
    pub ack_relay: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToClient.legacy_ack_e2e)
    pub legacy_ack_e2e: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToClient.flags)
    pub flags: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToClient.client_connection_id)
    pub client_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToClient.seq_num_r2c)
    pub seq_num_r2c: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToClient.seq_num_e2e)
    pub seq_num_e2e: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramConnectionStatsRouterToClient.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CMsgSteamDatagramConnectionStatsRouterToClient {
    fn default() -> &'a CMsgSteamDatagramConnectionStatsRouterToClient {
        <CMsgSteamDatagramConnectionStatsRouterToClient as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamDatagramConnectionStatsRouterToClient {
    pub fn new() -> CMsgSteamDatagramConnectionStatsRouterToClient {
        ::std::default::Default::default()
    }

    // optional uint32 seconds_until_shutdown = 6;

    pub fn seconds_until_shutdown(&self) -> u32 {
        self.seconds_until_shutdown.unwrap_or(0)
    }

    pub fn clear_seconds_until_shutdown(&mut self) {
        self.seconds_until_shutdown = ::std::option::Option::None;
    }

    pub fn has_seconds_until_shutdown(&self) -> bool {
        self.seconds_until_shutdown.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seconds_until_shutdown(&mut self, v: u32) {
        self.seconds_until_shutdown = ::std::option::Option::Some(v);
    }

    // optional fixed32 migrate_request_ip = 10;

    pub fn migrate_request_ip(&self) -> u32 {
        self.migrate_request_ip.unwrap_or(0)
    }

    pub fn clear_migrate_request_ip(&mut self) {
        self.migrate_request_ip = ::std::option::Option::None;
    }

    pub fn has_migrate_request_ip(&self) -> bool {
        self.migrate_request_ip.is_some()
    }

    // Param is passed by value, moved
    pub fn set_migrate_request_ip(&mut self, v: u32) {
        self.migrate_request_ip = ::std::option::Option::Some(v);
    }

    // optional uint32 migrate_request_port = 11;

    pub fn migrate_request_port(&self) -> u32 {
        self.migrate_request_port.unwrap_or(0)
    }

    pub fn clear_migrate_request_port(&mut self) {
        self.migrate_request_port = ::std::option::Option::None;
    }

    pub fn has_migrate_request_port(&self) -> bool {
        self.migrate_request_port.is_some()
    }

    // Param is passed by value, moved
    pub fn set_migrate_request_port(&mut self, v: u32) {
        self.migrate_request_port = ::std::option::Option::Some(v);
    }

    // optional uint32 scoring_penalty_relay_cluster = 12;

    pub fn scoring_penalty_relay_cluster(&self) -> u32 {
        self.scoring_penalty_relay_cluster.unwrap_or(0)
    }

    pub fn clear_scoring_penalty_relay_cluster(&mut self) {
        self.scoring_penalty_relay_cluster = ::std::option::Option::None;
    }

    pub fn has_scoring_penalty_relay_cluster(&self) -> bool {
        self.scoring_penalty_relay_cluster.is_some()
    }

    // Param is passed by value, moved
    pub fn set_scoring_penalty_relay_cluster(&mut self, v: u32) {
        self.scoring_penalty_relay_cluster = ::std::option::Option::Some(v);
    }

    // optional uint32 flags = 15;

    pub fn flags(&self) -> u32 {
        self.flags.unwrap_or(0)
    }

    pub fn clear_flags(&mut self) {
        self.flags = ::std::option::Option::None;
    }

    pub fn has_flags(&self) -> bool {
        self.flags.is_some()
    }

    // Param is passed by value, moved
    pub fn set_flags(&mut self, v: u32) {
        self.flags = ::std::option::Option::Some(v);
    }

    // optional fixed32 client_connection_id = 7;

    pub fn client_connection_id(&self) -> u32 {
        self.client_connection_id.unwrap_or(0)
    }

    pub fn clear_client_connection_id(&mut self) {
        self.client_connection_id = ::std::option::Option::None;
    }

    pub fn has_client_connection_id(&self) -> bool {
        self.client_connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_client_connection_id(&mut self, v: u32) {
        self.client_connection_id = ::std::option::Option::Some(v);
    }

    // optional uint32 seq_num_r2c = 8;

    pub fn seq_num_r2c(&self) -> u32 {
        self.seq_num_r2c.unwrap_or(0)
    }

    pub fn clear_seq_num_r2c(&mut self) {
        self.seq_num_r2c = ::std::option::Option::None;
    }

    pub fn has_seq_num_r2c(&self) -> bool {
        self.seq_num_r2c.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seq_num_r2c(&mut self, v: u32) {
        self.seq_num_r2c = ::std::option::Option::Some(v);
    }

    // optional uint32 seq_num_e2e = 9;

    pub fn seq_num_e2e(&self) -> u32 {
        self.seq_num_e2e.unwrap_or(0)
    }

    pub fn clear_seq_num_e2e(&mut self) {
        self.seq_num_e2e = ::std::option::Option::None;
    }

    pub fn has_seq_num_e2e(&self) -> bool {
        self.seq_num_e2e.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seq_num_e2e(&mut self, v: u32) {
        self.seq_num_e2e = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CMsgSteamDatagramConnectionStatsRouterToClient {
    const NAME: &'static str = "CMsgSteamDatagramConnectionStatsRouterToClient";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_relay)?;
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_e2e)?;
                },
                48 => {
                    self.seconds_until_shutdown = ::std::option::Option::Some(is.read_uint32()?);
                },
                85 => {
                    self.migrate_request_ip = ::std::option::Option::Some(is.read_fixed32()?);
                },
                88 => {
                    self.migrate_request_port = ::std::option::Option::Some(is.read_uint32()?);
                },
                96 => {
                    self.scoring_penalty_relay_cluster = ::std::option::Option::Some(is.read_uint32()?);
                },
                106 => {
                    is.read_repeated_packed_fixed32_into(&mut self.ack_relay)?;
                },
                109 => {
                    self.ack_relay.push(is.read_fixed32()?);
                },
                114 => {
                    is.read_repeated_packed_fixed32_into(&mut self.legacy_ack_e2e)?;
                },
                117 => {
                    self.legacy_ack_e2e.push(is.read_fixed32()?);
                },
                120 => {
                    self.flags = ::std::option::Option::Some(is.read_uint32()?);
                },
                61 => {
                    self.client_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                64 => {
                    self.seq_num_r2c = ::std::option::Option::Some(is.read_uint32()?);
                },
                72 => {
                    self.seq_num_e2e = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.quality_relay.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.seconds_until_shutdown {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.migrate_request_ip {
            my_size += 1 + 4;
        }
        if let Some(v) = self.migrate_request_port {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(11, v);
        }
        if let Some(v) = self.scoring_penalty_relay_cluster {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(12, v);
        }
        my_size += 5 * self.ack_relay.len() as u64;
        my_size += 5 * self.legacy_ack_e2e.len() as u64;
        if let Some(v) = self.flags {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(15, v);
        }
        if let Some(v) = self.client_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.seq_num_r2c {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, v);
        }
        if let Some(v) = self.seq_num_e2e {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.quality_relay.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if let Some(v) = self.seconds_until_shutdown {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.migrate_request_ip {
            os.write_fixed32(10, v)?;
        }
        if let Some(v) = self.migrate_request_port {
            os.write_uint32(11, v)?;
        }
        if let Some(v) = self.scoring_penalty_relay_cluster {
            os.write_uint32(12, v)?;
        }
        for v in &self.ack_relay {
            os.write_fixed32(13, *v)?;
        };
        for v in &self.legacy_ack_e2e {
            os.write_fixed32(14, *v)?;
        };
        if let Some(v) = self.flags {
            os.write_uint32(15, v)?;
        }
        if let Some(v) = self.client_connection_id {
            os.write_fixed32(7, v)?;
        }
        if let Some(v) = self.seq_num_r2c {
            os.write_uint32(8, v)?;
        }
        if let Some(v) = self.seq_num_e2e {
            os.write_uint32(9, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CMsgSteamDatagramConnectionStatsRouterToClient {
        CMsgSteamDatagramConnectionStatsRouterToClient::new()
    }

    fn clear(&mut self) {
        self.quality_relay.clear();
        self.quality_e2e.clear();
        self.seconds_until_shutdown = ::std::option::Option::None;
        self.migrate_request_ip = ::std::option::Option::None;
        self.migrate_request_port = ::std::option::Option::None;
        self.scoring_penalty_relay_cluster = ::std::option::Option::None;
        self.ack_relay.clear();
        self.legacy_ack_e2e.clear();
        self.flags = ::std::option::Option::None;
        self.client_connection_id = ::std::option::Option::None;
        self.seq_num_r2c = ::std::option::Option::None;
        self.seq_num_e2e = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramConnectionStatsRouterToClient {
        static instance: CMsgSteamDatagramConnectionStatsRouterToClient = CMsgSteamDatagramConnectionStatsRouterToClient {
            quality_relay: ::steam_vent_proto_common::protobuf::MessageField::none(),
            quality_e2e: ::steam_vent_proto_common::protobuf::MessageField::none(),
            seconds_until_shutdown: ::std::option::Option::None,
            migrate_request_ip: ::std::option::Option::None,
            migrate_request_port: ::std::option::Option::None,
            scoring_penalty_relay_cluster: ::std::option::Option::None,
            ack_relay: ::std::vec::Vec::new(),
            legacy_ack_e2e: ::std::vec::Vec::new(),
            flags: ::std::option::Option::None,
            client_connection_id: ::std::option::Option::None,
            seq_num_r2c: ::std::option::Option::None,
            seq_num_e2e: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CMsgSteamDatagramConnectionStatsRouterToClient`
pub mod cmsg_steam_datagram_connection_stats_router_to_client {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    // @@protoc_insertion_point(enum:CMsgSteamDatagramConnectionStatsRouterToClient.Flags)
    pub enum Flags {
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsRouterToClient.Flags.ACK_REQUEST_RELAY)
        ACK_REQUEST_RELAY = 1,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsRouterToClient.Flags.ACK_REQUEST_E2E)
        ACK_REQUEST_E2E = 2,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsRouterToClient.Flags.ACK_REQUEST_IMMEDIATE)
        ACK_REQUEST_IMMEDIATE = 4,
    }

    impl ::steam_vent_proto_common::protobuf::Enum for Flags {
        const NAME: &'static str = "Flags";

        fn value(&self) -> i32 {
            *self as i32
        }

        fn from_i32(value: i32) -> ::std::option::Option<Flags> {
            match value {
                1 => ::std::option::Option::Some(Flags::ACK_REQUEST_RELAY),
                2 => ::std::option::Option::Some(Flags::ACK_REQUEST_E2E),
                4 => ::std::option::Option::Some(Flags::ACK_REQUEST_IMMEDIATE),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Flags> {
            match str {
                "ACK_REQUEST_RELAY" => ::std::option::Option::Some(Flags::ACK_REQUEST_RELAY),
                "ACK_REQUEST_E2E" => ::std::option::Option::Some(Flags::ACK_REQUEST_E2E),
                "ACK_REQUEST_IMMEDIATE" => ::std::option::Option::Some(Flags::ACK_REQUEST_IMMEDIATE),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Flags] = &[
            Flags::ACK_REQUEST_RELAY,
            Flags::ACK_REQUEST_E2E,
            Flags::ACK_REQUEST_IMMEDIATE,
        ];
    }

    // Note, `Default` is implemented although default value is not 0
    impl ::std::default::Default for Flags {
        fn default() -> Self {
            Flags::ACK_REQUEST_RELAY
        }
    }

}

// @@protoc_insertion_point(message:CMsgSteamDatagramConnectionStatsRouterToServer)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramConnectionStatsRouterToServer {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToServer.quality_relay)
    pub quality_relay: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToServer.quality_e2e)
    pub quality_e2e: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToServer.ack_relay)
    pub ack_relay: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToServer.legacy_ack_e2e)
    pub legacy_ack_e2e: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToServer.flags)
    pub flags: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToServer.seq_num_r2s)
    pub seq_num_r2s: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToServer.seq_num_e2e)
    pub seq_num_e2e: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToServer.client_identity_string)
    pub client_identity_string: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToServer.legacy_client_steam_id)
    pub legacy_client_steam_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToServer.relay_session_id)
    pub relay_session_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToServer.client_connection_id)
    pub client_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToServer.server_connection_id)
    pub server_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsRouterToServer.routing_secret)
    pub routing_secret: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramConnectionStatsRouterToServer.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CMsgSteamDatagramConnectionStatsRouterToServer {
    fn default() -> &'a CMsgSteamDatagramConnectionStatsRouterToServer {
        <CMsgSteamDatagramConnectionStatsRouterToServer as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamDatagramConnectionStatsRouterToServer {
    pub fn new() -> CMsgSteamDatagramConnectionStatsRouterToServer {
        ::std::default::Default::default()
    }

    // optional uint32 flags = 12;

    pub fn flags(&self) -> u32 {
        self.flags.unwrap_or(0)
    }

    pub fn clear_flags(&mut self) {
        self.flags = ::std::option::Option::None;
    }

    pub fn has_flags(&self) -> bool {
        self.flags.is_some()
    }

    // Param is passed by value, moved
    pub fn set_flags(&mut self, v: u32) {
        self.flags = ::std::option::Option::Some(v);
    }

    // optional uint32 seq_num_r2s = 5;

    pub fn seq_num_r2s(&self) -> u32 {
        self.seq_num_r2s.unwrap_or(0)
    }

    pub fn clear_seq_num_r2s(&mut self) {
        self.seq_num_r2s = ::std::option::Option::None;
    }

    pub fn has_seq_num_r2s(&self) -> bool {
        self.seq_num_r2s.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seq_num_r2s(&mut self, v: u32) {
        self.seq_num_r2s = ::std::option::Option::Some(v);
    }

    // optional uint32 seq_num_e2e = 6;

    pub fn seq_num_e2e(&self) -> u32 {
        self.seq_num_e2e.unwrap_or(0)
    }

    pub fn clear_seq_num_e2e(&mut self) {
        self.seq_num_e2e = ::std::option::Option::None;
    }

    pub fn has_seq_num_e2e(&self) -> bool {
        self.seq_num_e2e.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seq_num_e2e(&mut self, v: u32) {
        self.seq_num_e2e = ::std::option::Option::Some(v);
    }

    // optional string client_identity_string = 15;

    pub fn client_identity_string(&self) -> &str {
        match self.client_identity_string.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_client_identity_string(&mut self) {
        self.client_identity_string = ::std::option::Option::None;
    }

    pub fn has_client_identity_string(&self) -> bool {
        self.client_identity_string.is_some()
    }

    // Param is passed by value, moved
    pub fn set_client_identity_string(&mut self, v: ::std::string::String) {
        self.client_identity_string = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_client_identity_string(&mut self) -> &mut ::std::string::String {
        if self.client_identity_string.is_none() {
            self.client_identity_string = ::std::option::Option::Some(::std::string::String::new());
        }
        self.client_identity_string.as_mut().unwrap()
    }

    // Take field
    pub fn take_client_identity_string(&mut self) -> ::std::string::String {
        self.client_identity_string.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional fixed64 legacy_client_steam_id = 7;

    pub fn legacy_client_steam_id(&self) -> u64 {
        self.legacy_client_steam_id.unwrap_or(0)
    }

    pub fn clear_legacy_client_steam_id(&mut self) {
        self.legacy_client_steam_id = ::std::option::Option::None;
    }

    pub fn has_legacy_client_steam_id(&self) -> bool {
        self.legacy_client_steam_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_legacy_client_steam_id(&mut self, v: u64) {
        self.legacy_client_steam_id = ::std::option::Option::Some(v);
    }

    // optional uint32 relay_session_id = 8;

    pub fn relay_session_id(&self) -> u32 {
        self.relay_session_id.unwrap_or(0)
    }

    pub fn clear_relay_session_id(&mut self) {
        self.relay_session_id = ::std::option::Option::None;
    }

    pub fn has_relay_session_id(&self) -> bool {
        self.relay_session_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_relay_session_id(&mut self, v: u32) {
        self.relay_session_id = ::std::option::Option::Some(v);
    }

    // optional fixed32 client_connection_id = 9;

    pub fn client_connection_id(&self) -> u32 {
        self.client_connection_id.unwrap_or(0)
    }

    pub fn clear_client_connection_id(&mut self) {
        self.client_connection_id = ::std::option::Option::None;
    }

    pub fn has_client_connection_id(&self) -> bool {
        self.client_connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_client_connection_id(&mut self, v: u32) {
        self.client_connection_id = ::std::option::Option::Some(v);
    }

    // optional fixed32 server_connection_id = 13;

    pub fn server_connection_id(&self) -> u32 {
        self.server_connection_id.unwrap_or(0)
    }

    pub fn clear_server_connection_id(&mut self) {
        self.server_connection_id = ::std::option::Option::None;
    }

    pub fn has_server_connection_id(&self) -> bool {
        self.server_connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_server_connection_id(&mut self, v: u32) {
        self.server_connection_id = ::std::option::Option::Some(v);
    }

    // optional fixed64 routing_secret = 14;

    pub fn 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 ::steam_vent_proto_common::protobuf::Message for CMsgSteamDatagramConnectionStatsRouterToServer {
    const NAME: &'static str = "CMsgSteamDatagramConnectionStatsRouterToServer";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_relay)?;
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_e2e)?;
                },
                82 => {
                    is.read_repeated_packed_fixed32_into(&mut self.ack_relay)?;
                },
                85 => {
                    self.ack_relay.push(is.read_fixed32()?);
                },
                90 => {
                    is.read_repeated_packed_fixed32_into(&mut self.legacy_ack_e2e)?;
                },
                93 => {
                    self.legacy_ack_e2e.push(is.read_fixed32()?);
                },
                96 => {
                    self.flags = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.seq_num_r2s = ::std::option::Option::Some(is.read_uint32()?);
                },
                48 => {
                    self.seq_num_e2e = ::std::option::Option::Some(is.read_uint32()?);
                },
                122 => {
                    self.client_identity_string = ::std::option::Option::Some(is.read_string()?);
                },
                57 => {
                    self.legacy_client_steam_id = ::std::option::Option::Some(is.read_fixed64()?);
                },
                64 => {
                    self.relay_session_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                77 => {
                    self.client_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                109 => {
                    self.server_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                113 => {
                    self.routing_secret = ::std::option::Option::Some(is.read_fixed64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.quality_relay.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += 5 * self.ack_relay.len() as u64;
        my_size += 5 * self.legacy_ack_e2e.len() as u64;
        if let Some(v) = self.flags {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(12, v);
        }
        if let Some(v) = self.seq_num_r2s {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.seq_num_e2e {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.client_identity_string.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(15, &v);
        }
        if let Some(v) = self.legacy_client_steam_id {
            my_size += 1 + 8;
        }
        if let Some(v) = self.relay_session_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, v);
        }
        if let Some(v) = self.client_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.server_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.routing_secret {
            my_size += 1 + 8;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.quality_relay.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        for v in &self.ack_relay {
            os.write_fixed32(10, *v)?;
        };
        for v in &self.legacy_ack_e2e {
            os.write_fixed32(11, *v)?;
        };
        if let Some(v) = self.flags {
            os.write_uint32(12, v)?;
        }
        if let Some(v) = self.seq_num_r2s {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.seq_num_e2e {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.client_identity_string.as_ref() {
            os.write_string(15, v)?;
        }
        if let Some(v) = self.legacy_client_steam_id {
            os.write_fixed64(7, v)?;
        }
        if let Some(v) = self.relay_session_id {
            os.write_uint32(8, v)?;
        }
        if let Some(v) = self.client_connection_id {
            os.write_fixed32(9, v)?;
        }
        if let Some(v) = self.server_connection_id {
            os.write_fixed32(13, v)?;
        }
        if let Some(v) = self.routing_secret {
            os.write_fixed64(14, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CMsgSteamDatagramConnectionStatsRouterToServer {
        CMsgSteamDatagramConnectionStatsRouterToServer::new()
    }

    fn clear(&mut self) {
        self.quality_relay.clear();
        self.quality_e2e.clear();
        self.ack_relay.clear();
        self.legacy_ack_e2e.clear();
        self.flags = ::std::option::Option::None;
        self.seq_num_r2s = ::std::option::Option::None;
        self.seq_num_e2e = ::std::option::Option::None;
        self.client_identity_string = ::std::option::Option::None;
        self.legacy_client_steam_id = ::std::option::Option::None;
        self.relay_session_id = ::std::option::Option::None;
        self.client_connection_id = ::std::option::Option::None;
        self.server_connection_id = ::std::option::Option::None;
        self.routing_secret = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramConnectionStatsRouterToServer {
        static instance: CMsgSteamDatagramConnectionStatsRouterToServer = CMsgSteamDatagramConnectionStatsRouterToServer {
            quality_relay: ::steam_vent_proto_common::protobuf::MessageField::none(),
            quality_e2e: ::steam_vent_proto_common::protobuf::MessageField::none(),
            ack_relay: ::std::vec::Vec::new(),
            legacy_ack_e2e: ::std::vec::Vec::new(),
            flags: ::std::option::Option::None,
            seq_num_r2s: ::std::option::Option::None,
            seq_num_e2e: ::std::option::Option::None,
            client_identity_string: ::std::option::Option::None,
            legacy_client_steam_id: ::std::option::Option::None,
            relay_session_id: ::std::option::Option::None,
            client_connection_id: ::std::option::Option::None,
            server_connection_id: ::std::option::Option::None,
            routing_secret: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CMsgSteamDatagramConnectionStatsRouterToServer`
pub mod cmsg_steam_datagram_connection_stats_router_to_server {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    // @@protoc_insertion_point(enum:CMsgSteamDatagramConnectionStatsRouterToServer.Flags)
    pub enum Flags {
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsRouterToServer.Flags.ACK_REQUEST_RELAY)
        ACK_REQUEST_RELAY = 1,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsRouterToServer.Flags.ACK_REQUEST_E2E)
        ACK_REQUEST_E2E = 2,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsRouterToServer.Flags.ACK_REQUEST_IMMEDIATE)
        ACK_REQUEST_IMMEDIATE = 4,
    }

    impl ::steam_vent_proto_common::protobuf::Enum for Flags {
        const NAME: &'static str = "Flags";

        fn value(&self) -> i32 {
            *self as i32
        }

        fn from_i32(value: i32) -> ::std::option::Option<Flags> {
            match value {
                1 => ::std::option::Option::Some(Flags::ACK_REQUEST_RELAY),
                2 => ::std::option::Option::Some(Flags::ACK_REQUEST_E2E),
                4 => ::std::option::Option::Some(Flags::ACK_REQUEST_IMMEDIATE),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Flags> {
            match str {
                "ACK_REQUEST_RELAY" => ::std::option::Option::Some(Flags::ACK_REQUEST_RELAY),
                "ACK_REQUEST_E2E" => ::std::option::Option::Some(Flags::ACK_REQUEST_E2E),
                "ACK_REQUEST_IMMEDIATE" => ::std::option::Option::Some(Flags::ACK_REQUEST_IMMEDIATE),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Flags] = &[
            Flags::ACK_REQUEST_RELAY,
            Flags::ACK_REQUEST_E2E,
            Flags::ACK_REQUEST_IMMEDIATE,
        ];
    }

    // Note, `Default` is implemented although default value is not 0
    impl ::std::default::Default for Flags {
        fn default() -> Self {
            Flags::ACK_REQUEST_RELAY
        }
    }

}

// @@protoc_insertion_point(message:CMsgSteamDatagramConnectionStatsServerToRouter)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramConnectionStatsServerToRouter {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsServerToRouter.quality_relay)
    pub quality_relay: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsServerToRouter.quality_e2e)
    pub quality_e2e: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsServerToRouter.ack_relay)
    pub ack_relay: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsServerToRouter.legacy_ack_e2e)
    pub legacy_ack_e2e: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsServerToRouter.flags)
    pub flags: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsServerToRouter.seq_num_s2r)
    pub seq_num_s2r: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsServerToRouter.seq_num_e2e)
    pub seq_num_e2e: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsServerToRouter.relay_session_id)
    pub relay_session_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsServerToRouter.client_connection_id)
    pub client_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsServerToRouter.server_connection_id)
    pub server_connection_id: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramConnectionStatsServerToRouter.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CMsgSteamDatagramConnectionStatsServerToRouter {
    fn default() -> &'a CMsgSteamDatagramConnectionStatsServerToRouter {
        <CMsgSteamDatagramConnectionStatsServerToRouter as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamDatagramConnectionStatsServerToRouter {
    pub fn new() -> CMsgSteamDatagramConnectionStatsServerToRouter {
        ::std::default::Default::default()
    }

    // optional uint32 flags = 10;

    pub fn flags(&self) -> u32 {
        self.flags.unwrap_or(0)
    }

    pub fn clear_flags(&mut self) {
        self.flags = ::std::option::Option::None;
    }

    pub fn has_flags(&self) -> bool {
        self.flags.is_some()
    }

    // Param is passed by value, moved
    pub fn set_flags(&mut self, v: u32) {
        self.flags = ::std::option::Option::Some(v);
    }

    // optional uint32 seq_num_s2r = 3;

    pub fn seq_num_s2r(&self) -> u32 {
        self.seq_num_s2r.unwrap_or(0)
    }

    pub fn clear_seq_num_s2r(&mut self) {
        self.seq_num_s2r = ::std::option::Option::None;
    }

    pub fn has_seq_num_s2r(&self) -> bool {
        self.seq_num_s2r.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seq_num_s2r(&mut self, v: u32) {
        self.seq_num_s2r = ::std::option::Option::Some(v);
    }

    // optional uint32 seq_num_e2e = 4;

    pub fn seq_num_e2e(&self) -> u32 {
        self.seq_num_e2e.unwrap_or(0)
    }

    pub fn clear_seq_num_e2e(&mut self) {
        self.seq_num_e2e = ::std::option::Option::None;
    }

    pub fn has_seq_num_e2e(&self) -> bool {
        self.seq_num_e2e.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seq_num_e2e(&mut self, v: u32) {
        self.seq_num_e2e = ::std::option::Option::Some(v);
    }

    // optional uint32 relay_session_id = 6;

    pub fn relay_session_id(&self) -> u32 {
        self.relay_session_id.unwrap_or(0)
    }

    pub fn clear_relay_session_id(&mut self) {
        self.relay_session_id = ::std::option::Option::None;
    }

    pub fn has_relay_session_id(&self) -> bool {
        self.relay_session_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_relay_session_id(&mut self, v: u32) {
        self.relay_session_id = ::std::option::Option::Some(v);
    }

    // optional fixed32 client_connection_id = 7;

    pub fn client_connection_id(&self) -> u32 {
        self.client_connection_id.unwrap_or(0)
    }

    pub fn clear_client_connection_id(&mut self) {
        self.client_connection_id = ::std::option::Option::None;
    }

    pub fn has_client_connection_id(&self) -> bool {
        self.client_connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_client_connection_id(&mut self, v: u32) {
        self.client_connection_id = ::std::option::Option::Some(v);
    }

    // optional fixed32 server_connection_id = 11;

    pub fn server_connection_id(&self) -> u32 {
        self.server_connection_id.unwrap_or(0)
    }

    pub fn clear_server_connection_id(&mut self) {
        self.server_connection_id = ::std::option::Option::None;
    }

    pub fn has_server_connection_id(&self) -> bool {
        self.server_connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_server_connection_id(&mut self, v: u32) {
        self.server_connection_id = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CMsgSteamDatagramConnectionStatsServerToRouter {
    const NAME: &'static str = "CMsgSteamDatagramConnectionStatsServerToRouter";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_relay)?;
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_e2e)?;
                },
                66 => {
                    is.read_repeated_packed_fixed32_into(&mut self.ack_relay)?;
                },
                69 => {
                    self.ack_relay.push(is.read_fixed32()?);
                },
                74 => {
                    is.read_repeated_packed_fixed32_into(&mut self.legacy_ack_e2e)?;
                },
                77 => {
                    self.legacy_ack_e2e.push(is.read_fixed32()?);
                },
                80 => {
                    self.flags = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.seq_num_s2r = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.seq_num_e2e = ::std::option::Option::Some(is.read_uint32()?);
                },
                48 => {
                    self.relay_session_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                61 => {
                    self.client_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                93 => {
                    self.server_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.quality_relay.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += 5 * self.ack_relay.len() as u64;
        my_size += 5 * self.legacy_ack_e2e.len() as u64;
        if let Some(v) = self.flags {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(10, v);
        }
        if let Some(v) = self.seq_num_s2r {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.seq_num_e2e {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.relay_session_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.client_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.server_connection_id {
            my_size += 1 + 4;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.quality_relay.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        for v in &self.ack_relay {
            os.write_fixed32(8, *v)?;
        };
        for v in &self.legacy_ack_e2e {
            os.write_fixed32(9, *v)?;
        };
        if let Some(v) = self.flags {
            os.write_uint32(10, v)?;
        }
        if let Some(v) = self.seq_num_s2r {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.seq_num_e2e {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.relay_session_id {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.client_connection_id {
            os.write_fixed32(7, v)?;
        }
        if let Some(v) = self.server_connection_id {
            os.write_fixed32(11, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CMsgSteamDatagramConnectionStatsServerToRouter {
        CMsgSteamDatagramConnectionStatsServerToRouter::new()
    }

    fn clear(&mut self) {
        self.quality_relay.clear();
        self.quality_e2e.clear();
        self.ack_relay.clear();
        self.legacy_ack_e2e.clear();
        self.flags = ::std::option::Option::None;
        self.seq_num_s2r = ::std::option::Option::None;
        self.seq_num_e2e = ::std::option::Option::None;
        self.relay_session_id = ::std::option::Option::None;
        self.client_connection_id = ::std::option::Option::None;
        self.server_connection_id = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramConnectionStatsServerToRouter {
        static instance: CMsgSteamDatagramConnectionStatsServerToRouter = CMsgSteamDatagramConnectionStatsServerToRouter {
            quality_relay: ::steam_vent_proto_common::protobuf::MessageField::none(),
            quality_e2e: ::steam_vent_proto_common::protobuf::MessageField::none(),
            ack_relay: ::std::vec::Vec::new(),
            legacy_ack_e2e: ::std::vec::Vec::new(),
            flags: ::std::option::Option::None,
            seq_num_s2r: ::std::option::Option::None,
            seq_num_e2e: ::std::option::Option::None,
            relay_session_id: ::std::option::Option::None,
            client_connection_id: ::std::option::Option::None,
            server_connection_id: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CMsgSteamDatagramConnectionStatsServerToRouter`
pub mod cmsg_steam_datagram_connection_stats_server_to_router {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    // @@protoc_insertion_point(enum:CMsgSteamDatagramConnectionStatsServerToRouter.Flags)
    pub enum Flags {
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsServerToRouter.Flags.ACK_REQUEST_RELAY)
        ACK_REQUEST_RELAY = 1,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsServerToRouter.Flags.ACK_REQUEST_E2E)
        ACK_REQUEST_E2E = 2,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsServerToRouter.Flags.ACK_REQUEST_IMMEDIATE)
        ACK_REQUEST_IMMEDIATE = 4,
    }

    impl ::steam_vent_proto_common::protobuf::Enum for Flags {
        const NAME: &'static str = "Flags";

        fn value(&self) -> i32 {
            *self as i32
        }

        fn from_i32(value: i32) -> ::std::option::Option<Flags> {
            match value {
                1 => ::std::option::Option::Some(Flags::ACK_REQUEST_RELAY),
                2 => ::std::option::Option::Some(Flags::ACK_REQUEST_E2E),
                4 => ::std::option::Option::Some(Flags::ACK_REQUEST_IMMEDIATE),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Flags> {
            match str {
                "ACK_REQUEST_RELAY" => ::std::option::Option::Some(Flags::ACK_REQUEST_RELAY),
                "ACK_REQUEST_E2E" => ::std::option::Option::Some(Flags::ACK_REQUEST_E2E),
                "ACK_REQUEST_IMMEDIATE" => ::std::option::Option::Some(Flags::ACK_REQUEST_IMMEDIATE),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Flags] = &[
            Flags::ACK_REQUEST_RELAY,
            Flags::ACK_REQUEST_E2E,
            Flags::ACK_REQUEST_IMMEDIATE,
        ];
    }

    // Note, `Default` is implemented although default value is not 0
    impl ::std::default::Default for Flags {
        fn default() -> Self {
            Flags::ACK_REQUEST_RELAY
        }
    }

}

// @@protoc_insertion_point(message:CMsgSteamDatagramP2PSessionRequestBody)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramP2PSessionRequestBody {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequestBody.challenge_time)
    pub challenge_time: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequestBody.challenge)
    pub challenge: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequestBody.client_connection_id)
    pub client_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequestBody.legacy_peer_steam_id)
    pub legacy_peer_steam_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequestBody.peer_identity_string)
    pub peer_identity_string: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequestBody.peer_connection_id)
    pub peer_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequestBody.encrypted_data)
    pub encrypted_data: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequestBody.encryption_your_public_key_lead_byte)
    pub encryption_your_public_key_lead_byte: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequestBody.encryption_my_ephemeral_public_key)
    pub encryption_my_ephemeral_public_key: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequestBody.protocol_version)
    pub protocol_version: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequestBody.network_config_version)
    pub network_config_version: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequestBody.platform)
    pub platform: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequestBody.build)
    pub build: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramP2PSessionRequestBody.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CMsgSteamDatagramP2PSessionRequestBody {
    fn default() -> &'a CMsgSteamDatagramP2PSessionRequestBody {
        <CMsgSteamDatagramP2PSessionRequestBody as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamDatagramP2PSessionRequestBody {
    pub fn new() -> CMsgSteamDatagramP2PSessionRequestBody {
        ::std::default::Default::default()
    }

    // optional fixed32 challenge_time = 1;

    pub fn challenge_time(&self) -> u32 {
        self.challenge_time.unwrap_or(0)
    }

    pub fn clear_challenge_time(&mut self) {
        self.challenge_time = ::std::option::Option::None;
    }

    pub fn has_challenge_time(&self) -> bool {
        self.challenge_time.is_some()
    }

    // Param is passed by value, moved
    pub fn set_challenge_time(&mut self, v: u32) {
        self.challenge_time = ::std::option::Option::Some(v);
    }

    // optional fixed64 challenge = 2;

    pub fn challenge(&self) -> u64 {
        self.challenge.unwrap_or(0)
    }

    pub fn clear_challenge(&mut self) {
        self.challenge = ::std::option::Option::None;
    }

    pub fn has_challenge(&self) -> bool {
        self.challenge.is_some()
    }

    // Param is passed by value, moved
    pub fn set_challenge(&mut self, v: u64) {
        self.challenge = ::std::option::Option::Some(v);
    }

    // optional fixed32 client_connection_id = 3;

    pub fn client_connection_id(&self) -> u32 {
        self.client_connection_id.unwrap_or(0)
    }

    pub fn clear_client_connection_id(&mut self) {
        self.client_connection_id = ::std::option::Option::None;
    }

    pub fn has_client_connection_id(&self) -> bool {
        self.client_connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_client_connection_id(&mut self, v: u32) {
        self.client_connection_id = ::std::option::Option::Some(v);
    }

    // optional fixed64 legacy_peer_steam_id = 4;

    pub fn legacy_peer_steam_id(&self) -> u64 {
        self.legacy_peer_steam_id.unwrap_or(0)
    }

    pub fn clear_legacy_peer_steam_id(&mut self) {
        self.legacy_peer_steam_id = ::std::option::Option::None;
    }

    pub fn has_legacy_peer_steam_id(&self) -> bool {
        self.legacy_peer_steam_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_legacy_peer_steam_id(&mut self, v: u64) {
        self.legacy_peer_steam_id = ::std::option::Option::Some(v);
    }

    // optional string peer_identity_string = 11;

    pub fn peer_identity_string(&self) -> &str {
        match self.peer_identity_string.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_peer_identity_string(&mut self) {
        self.peer_identity_string = ::std::option::Option::None;
    }

    pub fn has_peer_identity_string(&self) -> bool {
        self.peer_identity_string.is_some()
    }

    // Param is passed by value, moved
    pub fn set_peer_identity_string(&mut self, v: ::std::string::String) {
        self.peer_identity_string = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_peer_identity_string(&mut self) -> &mut ::std::string::String {
        if self.peer_identity_string.is_none() {
            self.peer_identity_string = ::std::option::Option::Some(::std::string::String::new());
        }
        self.peer_identity_string.as_mut().unwrap()
    }

    // Take field
    pub fn take_peer_identity_string(&mut self) -> ::std::string::String {
        self.peer_identity_string.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional fixed32 peer_connection_id = 5;

    pub fn peer_connection_id(&self) -> u32 {
        self.peer_connection_id.unwrap_or(0)
    }

    pub fn clear_peer_connection_id(&mut self) {
        self.peer_connection_id = ::std::option::Option::None;
    }

    pub fn has_peer_connection_id(&self) -> bool {
        self.peer_connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_peer_connection_id(&mut self, v: u32) {
        self.peer_connection_id = ::std::option::Option::Some(v);
    }

    // optional bytes encrypted_data = 14;

    pub fn encrypted_data(&self) -> &[u8] {
        match self.encrypted_data.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

    pub fn clear_encrypted_data(&mut self) {
        self.encrypted_data = ::std::option::Option::None;
    }

    pub fn has_encrypted_data(&self) -> bool {
        self.encrypted_data.is_some()
    }

    // Param is passed by value, moved
    pub fn set_encrypted_data(&mut self, v: ::std::vec::Vec<u8>) {
        self.encrypted_data = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_encrypted_data(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.encrypted_data.is_none() {
            self.encrypted_data = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.encrypted_data.as_mut().unwrap()
    }

    // Take field
    pub fn take_encrypted_data(&mut self) -> ::std::vec::Vec<u8> {
        self.encrypted_data.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional uint32 encryption_your_public_key_lead_byte = 15;

    pub fn encryption_your_public_key_lead_byte(&self) -> u32 {
        self.encryption_your_public_key_lead_byte.unwrap_or(0)
    }

    pub fn clear_encryption_your_public_key_lead_byte(&mut self) {
        self.encryption_your_public_key_lead_byte = ::std::option::Option::None;
    }

    pub fn has_encryption_your_public_key_lead_byte(&self) -> bool {
        self.encryption_your_public_key_lead_byte.is_some()
    }

    // Param is passed by value, moved
    pub fn set_encryption_your_public_key_lead_byte(&mut self, v: u32) {
        self.encryption_your_public_key_lead_byte = ::std::option::Option::Some(v);
    }

    // optional bytes encryption_my_ephemeral_public_key = 16;

    pub fn encryption_my_ephemeral_public_key(&self) -> &[u8] {
        match self.encryption_my_ephemeral_public_key.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

    pub fn clear_encryption_my_ephemeral_public_key(&mut self) {
        self.encryption_my_ephemeral_public_key = ::std::option::Option::None;
    }

    pub fn has_encryption_my_ephemeral_public_key(&self) -> bool {
        self.encryption_my_ephemeral_public_key.is_some()
    }

    // Param is passed by value, moved
    pub fn set_encryption_my_ephemeral_public_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.encryption_my_ephemeral_public_key = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_encryption_my_ephemeral_public_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.encryption_my_ephemeral_public_key.is_none() {
            self.encryption_my_ephemeral_public_key = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.encryption_my_ephemeral_public_key.as_mut().unwrap()
    }

    // Take field
    pub fn take_encryption_my_ephemeral_public_key(&mut self) -> ::std::vec::Vec<u8> {
        self.encryption_my_ephemeral_public_key.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional uint32 protocol_version = 8;

    pub fn protocol_version(&self) -> u32 {
        self.protocol_version.unwrap_or(0)
    }

    pub fn clear_protocol_version(&mut self) {
        self.protocol_version = ::std::option::Option::None;
    }

    pub fn has_protocol_version(&self) -> bool {
        self.protocol_version.is_some()
    }

    // Param is passed by value, moved
    pub fn set_protocol_version(&mut self, v: u32) {
        self.protocol_version = ::std::option::Option::Some(v);
    }

    // optional uint64 network_config_version = 9;

    pub fn network_config_version(&self) -> u64 {
        self.network_config_version.unwrap_or(0)
    }

    pub fn clear_network_config_version(&mut self) {
        self.network_config_version = ::std::option::Option::None;
    }

    pub fn has_network_config_version(&self) -> bool {
        self.network_config_version.is_some()
    }

    // Param is passed by value, moved
    pub fn set_network_config_version(&mut self, v: u64) {
        self.network_config_version = ::std::option::Option::Some(v);
    }

    // optional string platform = 12;

    pub fn platform(&self) -> &str {
        match self.platform.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_platform(&mut self) {
        self.platform = ::std::option::Option::None;
    }

    pub fn has_platform(&self) -> bool {
        self.platform.is_some()
    }

    // Param is passed by value, moved
    pub fn set_platform(&mut self, v: ::std::string::String) {
        self.platform = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_platform(&mut self) -> &mut ::std::string::String {
        if self.platform.is_none() {
            self.platform = ::std::option::Option::Some(::std::string::String::new());
        }
        self.platform.as_mut().unwrap()
    }

    // Take field
    pub fn take_platform(&mut self) -> ::std::string::String {
        self.platform.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string build = 13;

    pub fn build(&self) -> &str {
        match self.build.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_build(&mut self) {
        self.build = ::std::option::Option::None;
    }

    pub fn has_build(&self) -> bool {
        self.build.is_some()
    }

    // Param is passed by value, moved
    pub fn set_build(&mut self, v: ::std::string::String) {
        self.build = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_build(&mut self) -> &mut ::std::string::String {
        if self.build.is_none() {
            self.build = ::std::option::Option::Some(::std::string::String::new());
        }
        self.build.as_mut().unwrap()
    }

    // Take field
    pub fn take_build(&mut self) -> ::std::string::String {
        self.build.take().unwrap_or_else(|| ::std::string::String::new())
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CMsgSteamDatagramP2PSessionRequestBody {
    const NAME: &'static str = "CMsgSteamDatagramP2PSessionRequestBody";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                13 => {
                    self.challenge_time = ::std::option::Option::Some(is.read_fixed32()?);
                },
                17 => {
                    self.challenge = ::std::option::Option::Some(is.read_fixed64()?);
                },
                29 => {
                    self.client_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                33 => {
                    self.legacy_peer_steam_id = ::std::option::Option::Some(is.read_fixed64()?);
                },
                90 => {
                    self.peer_identity_string = ::std::option::Option::Some(is.read_string()?);
                },
                45 => {
                    self.peer_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                114 => {
                    self.encrypted_data = ::std::option::Option::Some(is.read_bytes()?);
                },
                120 => {
                    self.encryption_your_public_key_lead_byte = ::std::option::Option::Some(is.read_uint32()?);
                },
                130 => {
                    self.encryption_my_ephemeral_public_key = ::std::option::Option::Some(is.read_bytes()?);
                },
                64 => {
                    self.protocol_version = ::std::option::Option::Some(is.read_uint32()?);
                },
                72 => {
                    self.network_config_version = ::std::option::Option::Some(is.read_uint64()?);
                },
                98 => {
                    self.platform = ::std::option::Option::Some(is.read_string()?);
                },
                106 => {
                    self.build = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.challenge_time {
            my_size += 1 + 4;
        }
        if let Some(v) = self.challenge {
            my_size += 1 + 8;
        }
        if let Some(v) = self.client_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.legacy_peer_steam_id {
            my_size += 1 + 8;
        }
        if let Some(v) = self.peer_identity_string.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(11, &v);
        }
        if let Some(v) = self.peer_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.encrypted_data.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(14, &v);
        }
        if let Some(v) = self.encryption_your_public_key_lead_byte {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(15, v);
        }
        if let Some(v) = self.encryption_my_ephemeral_public_key.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(16, &v);
        }
        if let Some(v) = self.protocol_version {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, v);
        }
        if let Some(v) = self.network_config_version {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(9, v);
        }
        if let Some(v) = self.platform.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(12, &v);
        }
        if let Some(v) = self.build.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(13, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.challenge_time {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.challenge {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.client_connection_id {
            os.write_fixed32(3, v)?;
        }
        if let Some(v) = self.legacy_peer_steam_id {
            os.write_fixed64(4, v)?;
        }
        if let Some(v) = self.peer_identity_string.as_ref() {
            os.write_string(11, v)?;
        }
        if let Some(v) = self.peer_connection_id {
            os.write_fixed32(5, v)?;
        }
        if let Some(v) = self.encrypted_data.as_ref() {
            os.write_bytes(14, v)?;
        }
        if let Some(v) = self.encryption_your_public_key_lead_byte {
            os.write_uint32(15, v)?;
        }
        if let Some(v) = self.encryption_my_ephemeral_public_key.as_ref() {
            os.write_bytes(16, v)?;
        }
        if let Some(v) = self.protocol_version {
            os.write_uint32(8, v)?;
        }
        if let Some(v) = self.network_config_version {
            os.write_uint64(9, v)?;
        }
        if let Some(v) = self.platform.as_ref() {
            os.write_string(12, v)?;
        }
        if let Some(v) = self.build.as_ref() {
            os.write_string(13, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CMsgSteamDatagramP2PSessionRequestBody {
        CMsgSteamDatagramP2PSessionRequestBody::new()
    }

    fn clear(&mut self) {
        self.challenge_time = ::std::option::Option::None;
        self.challenge = ::std::option::Option::None;
        self.client_connection_id = ::std::option::Option::None;
        self.legacy_peer_steam_id = ::std::option::Option::None;
        self.peer_identity_string = ::std::option::Option::None;
        self.peer_connection_id = ::std::option::Option::None;
        self.encrypted_data = ::std::option::Option::None;
        self.encryption_your_public_key_lead_byte = ::std::option::Option::None;
        self.encryption_my_ephemeral_public_key = ::std::option::Option::None;
        self.protocol_version = ::std::option::Option::None;
        self.network_config_version = ::std::option::Option::None;
        self.platform = ::std::option::Option::None;
        self.build = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramP2PSessionRequestBody {
        static instance: CMsgSteamDatagramP2PSessionRequestBody = CMsgSteamDatagramP2PSessionRequestBody {
            challenge_time: ::std::option::Option::None,
            challenge: ::std::option::Option::None,
            client_connection_id: ::std::option::Option::None,
            legacy_peer_steam_id: ::std::option::Option::None,
            peer_identity_string: ::std::option::Option::None,
            peer_connection_id: ::std::option::Option::None,
            encrypted_data: ::std::option::Option::None,
            encryption_your_public_key_lead_byte: ::std::option::Option::None,
            encryption_my_ephemeral_public_key: ::std::option::Option::None,
            protocol_version: ::std::option::Option::None,
            network_config_version: ::std::option::Option::None,
            platform: ::std::option::Option::None,
            build: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CMsgSteamDatagramP2PSessionRequestBody`
pub mod cmsg_steam_datagram_p2psession_request_body {
    // @@protoc_insertion_point(message:CMsgSteamDatagramP2PSessionRequestBody.EncryptedData)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct EncryptedData {
        // message fields
        // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequestBody.EncryptedData.peer_identity_string)
        pub peer_identity_string: ::std::option::Option<::std::string::String>,
        // special fields
        // @@protoc_insertion_point(special_field:CMsgSteamDatagramP2PSessionRequestBody.EncryptedData.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

    impl<'a> ::std::default::Default for &'a EncryptedData {
        fn default() -> &'a EncryptedData {
            <EncryptedData as ::steam_vent_proto_common::protobuf::Message>::default_instance()
        }
    }

    impl EncryptedData {
        pub fn new() -> EncryptedData {
            ::std::default::Default::default()
        }

        // optional string peer_identity_string = 1;

        pub fn peer_identity_string(&self) -> &str {
            match self.peer_identity_string.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_peer_identity_string(&mut self) {
            self.peer_identity_string = ::std::option::Option::None;
        }

        pub fn has_peer_identity_string(&self) -> bool {
            self.peer_identity_string.is_some()
        }

        // Param is passed by value, moved
        pub fn set_peer_identity_string(&mut self, v: ::std::string::String) {
            self.peer_identity_string = ::std::option::Option::Some(v);
        }

        // Mutable pointer to the field.
        // If field is not initialized, it is initialized with default value first.
        pub fn mut_peer_identity_string(&mut self) -> &mut ::std::string::String {
            if self.peer_identity_string.is_none() {
                self.peer_identity_string = ::std::option::Option::Some(::std::string::String::new());
            }
            self.peer_identity_string.as_mut().unwrap()
        }

        // Take field
        pub fn take_peer_identity_string(&mut self) -> ::std::string::String {
            self.peer_identity_string.take().unwrap_or_else(|| ::std::string::String::new())
        }
    }

    impl ::steam_vent_proto_common::protobuf::Message for EncryptedData {
        const NAME: &'static str = "EncryptedData";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.peer_identity_string = ::std::option::Option::Some(is.read_string()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if let Some(v) = self.peer_identity_string.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.peer_identity_string.as_ref() {
                os.write_string(1, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
            &mut self.special_fields
        }

        fn new() -> EncryptedData {
            EncryptedData::new()
        }

        fn clear(&mut self) {
            self.peer_identity_string = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static EncryptedData {
            static instance: EncryptedData = EncryptedData {
                peer_identity_string: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramP2PSessionRequest)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramP2PSessionRequest {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequest.cert)
    pub cert: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequest.body)
    pub body: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionRequest.signature)
    pub signature: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramP2PSessionRequest.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CMsgSteamDatagramP2PSessionRequest {
    fn default() -> &'a CMsgSteamDatagramP2PSessionRequest {
        <CMsgSteamDatagramP2PSessionRequest as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamDatagramP2PSessionRequest {
    pub fn new() -> CMsgSteamDatagramP2PSessionRequest {
        ::std::default::Default::default()
    }

    // optional bytes body = 2;

    pub fn body(&self) -> &[u8] {
        match self.body.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

    pub fn clear_body(&mut self) {
        self.body = ::std::option::Option::None;
    }

    pub fn has_body(&self) -> bool {
        self.body.is_some()
    }

    // Param is passed by value, moved
    pub fn set_body(&mut self, v: ::std::vec::Vec<u8>) {
        self.body = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_body(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.body.is_none() {
            self.body = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.body.as_mut().unwrap()
    }

    // Take field
    pub fn take_body(&mut self) -> ::std::vec::Vec<u8> {
        self.body.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional bytes signature = 3;

    pub fn signature(&self) -> &[u8] {
        match self.signature.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

    pub fn clear_signature(&mut self) {
        self.signature = ::std::option::Option::None;
    }

    pub fn has_signature(&self) -> bool {
        self.signature.is_some()
    }

    // Param is passed by value, moved
    pub fn set_signature(&mut self, v: ::std::vec::Vec<u8>) {
        self.signature = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_signature(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.signature.is_none() {
            self.signature = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.signature.as_mut().unwrap()
    }

    // Take field
    pub fn take_signature(&mut self) -> ::std::vec::Vec<u8> {
        self.signature.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CMsgSteamDatagramP2PSessionRequest {
    const NAME: &'static str = "CMsgSteamDatagramP2PSessionRequest";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.cert)?;
                },
                18 => {
                    self.body = ::std::option::Option::Some(is.read_bytes()?);
                },
                26 => {
                    self.signature = ::std::option::Option::Some(is.read_bytes()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.cert.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.body.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(v) = self.signature.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(3, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.cert.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.body.as_ref() {
            os.write_bytes(2, v)?;
        }
        if let Some(v) = self.signature.as_ref() {
            os.write_bytes(3, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CMsgSteamDatagramP2PSessionRequest {
        CMsgSteamDatagramP2PSessionRequest::new()
    }

    fn clear(&mut self) {
        self.cert.clear();
        self.body = ::std::option::Option::None;
        self.signature = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramP2PSessionRequest {
        static instance: CMsgSteamDatagramP2PSessionRequest = CMsgSteamDatagramP2PSessionRequest {
            cert: ::steam_vent_proto_common::protobuf::MessageField::none(),
            body: ::std::option::Option::None,
            signature: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramP2PSessionEstablished)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramP2PSessionEstablished {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionEstablished.connection_id)
    pub connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionEstablished.seconds_until_shutdown)
    pub seconds_until_shutdown: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionEstablished.relay_routing_token)
    pub relay_routing_token: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PSessionEstablished.seq_num_r2c)
    pub seq_num_r2c: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramP2PSessionEstablished.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CMsgSteamDatagramP2PSessionEstablished {
    fn default() -> &'a CMsgSteamDatagramP2PSessionEstablished {
        <CMsgSteamDatagramP2PSessionEstablished as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamDatagramP2PSessionEstablished {
    pub fn new() -> CMsgSteamDatagramP2PSessionEstablished {
        ::std::default::Default::default()
    }

    // optional fixed32 connection_id = 1;

    pub fn connection_id(&self) -> u32 {
        self.connection_id.unwrap_or(0)
    }

    pub fn clear_connection_id(&mut self) {
        self.connection_id = ::std::option::Option::None;
    }

    pub fn has_connection_id(&self) -> bool {
        self.connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_connection_id(&mut self, v: u32) {
        self.connection_id = ::std::option::Option::Some(v);
    }

    // optional uint32 seconds_until_shutdown = 3;

    pub fn seconds_until_shutdown(&self) -> u32 {
        self.seconds_until_shutdown.unwrap_or(0)
    }

    pub fn clear_seconds_until_shutdown(&mut self) {
        self.seconds_until_shutdown = ::std::option::Option::None;
    }

    pub fn has_seconds_until_shutdown(&self) -> bool {
        self.seconds_until_shutdown.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seconds_until_shutdown(&mut self, v: u32) {
        self.seconds_until_shutdown = ::std::option::Option::Some(v);
    }

    // optional bytes relay_routing_token = 4;

    pub fn relay_routing_token(&self) -> &[u8] {
        match self.relay_routing_token.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

    pub fn clear_relay_routing_token(&mut self) {
        self.relay_routing_token = ::std::option::Option::None;
    }

    pub fn has_relay_routing_token(&self) -> bool {
        self.relay_routing_token.is_some()
    }

    // Param is passed by value, moved
    pub fn set_relay_routing_token(&mut self, v: ::std::vec::Vec<u8>) {
        self.relay_routing_token = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_relay_routing_token(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.relay_routing_token.is_none() {
            self.relay_routing_token = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.relay_routing_token.as_mut().unwrap()
    }

    // Take field
    pub fn take_relay_routing_token(&mut self) -> ::std::vec::Vec<u8> {
        self.relay_routing_token.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional uint32 seq_num_r2c = 5;

    pub fn seq_num_r2c(&self) -> u32 {
        self.seq_num_r2c.unwrap_or(0)
    }

    pub fn clear_seq_num_r2c(&mut self) {
        self.seq_num_r2c = ::std::option::Option::None;
    }

    pub fn has_seq_num_r2c(&self) -> bool {
        self.seq_num_r2c.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seq_num_r2c(&mut self, v: u32) {
        self.seq_num_r2c = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CMsgSteamDatagramP2PSessionEstablished {
    const NAME: &'static str = "CMsgSteamDatagramP2PSessionEstablished";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                13 => {
                    self.connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                24 => {
                    self.seconds_until_shutdown = ::std::option::Option::Some(is.read_uint32()?);
                },
                34 => {
                    self.relay_routing_token = ::std::option::Option::Some(is.read_bytes()?);
                },
                40 => {
                    self.seq_num_r2c = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.seconds_until_shutdown {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.relay_routing_token.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(4, &v);
        }
        if let Some(v) = self.seq_num_r2c {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.connection_id {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.seconds_until_shutdown {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.relay_routing_token.as_ref() {
            os.write_bytes(4, v)?;
        }
        if let Some(v) = self.seq_num_r2c {
            os.write_uint32(5, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CMsgSteamDatagramP2PSessionEstablished {
        CMsgSteamDatagramP2PSessionEstablished::new()
    }

    fn clear(&mut self) {
        self.connection_id = ::std::option::Option::None;
        self.seconds_until_shutdown = ::std::option::Option::None;
        self.relay_routing_token = ::std::option::Option::None;
        self.seq_num_r2c = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramP2PSessionEstablished {
        static instance: CMsgSteamDatagramP2PSessionEstablished = CMsgSteamDatagramP2PSessionEstablished {
            connection_id: ::std::option::Option::None,
            seconds_until_shutdown: ::std::option::Option::None,
            relay_routing_token: ::std::option::Option::None,
            seq_num_r2c: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramConnectionStatsP2PClientToRouter)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramConnectionStatsP2PClientToRouter {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PClientToRouter.quality_relay)
    pub quality_relay: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PClientToRouter.quality_e2e)
    pub quality_e2e: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PClientToRouter.p2p_routing_summary)
    pub p2p_routing_summary: ::steam_vent_proto_common::protobuf::MessageField<CMsgSteamDatagramP2PRoutingSummary>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PClientToRouter.ack_relay)
    pub ack_relay: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PClientToRouter.legacy_ack_e2e)
    pub legacy_ack_e2e: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PClientToRouter.flags)
    pub flags: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PClientToRouter.forward_target_relay_routing_token)
    pub forward_target_relay_routing_token: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PClientToRouter.forward_target_revision)
    pub forward_target_revision: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PClientToRouter.routes)
    pub routes: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PClientToRouter.ack_peer_routes_revision)
    pub ack_peer_routes_revision: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PClientToRouter.connection_id)
    pub connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PClientToRouter.seq_num_c2r)
    pub seq_num_c2r: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PClientToRouter.seq_num_e2e)
    pub seq_num_e2e: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramConnectionStatsP2PClientToRouter.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CMsgSteamDatagramConnectionStatsP2PClientToRouter {
    fn default() -> &'a CMsgSteamDatagramConnectionStatsP2PClientToRouter {
        <CMsgSteamDatagramConnectionStatsP2PClientToRouter as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamDatagramConnectionStatsP2PClientToRouter {
    pub fn new() -> CMsgSteamDatagramConnectionStatsP2PClientToRouter {
        ::std::default::Default::default()
    }

    // optional uint32 flags = 5;

    pub fn flags(&self) -> u32 {
        self.flags.unwrap_or(0)
    }

    pub fn clear_flags(&mut self) {
        self.flags = ::std::option::Option::None;
    }

    pub fn has_flags(&self) -> bool {
        self.flags.is_some()
    }

    // Param is passed by value, moved
    pub fn set_flags(&mut self, v: u32) {
        self.flags = ::std::option::Option::Some(v);
    }

    // optional bytes forward_target_relay_routing_token = 6;

    pub fn forward_target_relay_routing_token(&self) -> &[u8] {
        match self.forward_target_relay_routing_token.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

    pub fn clear_forward_target_relay_routing_token(&mut self) {
        self.forward_target_relay_routing_token = ::std::option::Option::None;
    }

    pub fn has_forward_target_relay_routing_token(&self) -> bool {
        self.forward_target_relay_routing_token.is_some()
    }

    // Param is passed by value, moved
    pub fn set_forward_target_relay_routing_token(&mut self, v: ::std::vec::Vec<u8>) {
        self.forward_target_relay_routing_token = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_forward_target_relay_routing_token(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.forward_target_relay_routing_token.is_none() {
            self.forward_target_relay_routing_token = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.forward_target_relay_routing_token.as_mut().unwrap()
    }

    // Take field
    pub fn take_forward_target_relay_routing_token(&mut self) -> ::std::vec::Vec<u8> {
        self.forward_target_relay_routing_token.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional uint32 forward_target_revision = 7;

    pub fn forward_target_revision(&self) -> u32 {
        self.forward_target_revision.unwrap_or(0)
    }

    pub fn clear_forward_target_revision(&mut self) {
        self.forward_target_revision = ::std::option::Option::None;
    }

    pub fn has_forward_target_revision(&self) -> bool {
        self.forward_target_revision.is_some()
    }

    // Param is passed by value, moved
    pub fn set_forward_target_revision(&mut self, v: u32) {
        self.forward_target_revision = ::std::option::Option::Some(v);
    }

    // optional bytes routes = 8;

    pub fn routes(&self) -> &[u8] {
        match self.routes.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

    pub fn clear_routes(&mut self) {
        self.routes = ::std::option::Option::None;
    }

    pub fn has_routes(&self) -> bool {
        self.routes.is_some()
    }

    // Param is passed by value, moved
    pub fn set_routes(&mut self, v: ::std::vec::Vec<u8>) {
        self.routes = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_routes(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.routes.is_none() {
            self.routes = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.routes.as_mut().unwrap()
    }

    // Take field
    pub fn take_routes(&mut self) -> ::std::vec::Vec<u8> {
        self.routes.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional uint32 ack_peer_routes_revision = 9;

    pub fn ack_peer_routes_revision(&self) -> u32 {
        self.ack_peer_routes_revision.unwrap_or(0)
    }

    pub fn clear_ack_peer_routes_revision(&mut self) {
        self.ack_peer_routes_revision = ::std::option::Option::None;
    }

    pub fn has_ack_peer_routes_revision(&self) -> bool {
        self.ack_peer_routes_revision.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ack_peer_routes_revision(&mut self, v: u32) {
        self.ack_peer_routes_revision = ::std::option::Option::Some(v);
    }

    // optional fixed32 connection_id = 10;

    pub fn connection_id(&self) -> u32 {
        self.connection_id.unwrap_or(0)
    }

    pub fn clear_connection_id(&mut self) {
        self.connection_id = ::std::option::Option::None;
    }

    pub fn has_connection_id(&self) -> bool {
        self.connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_connection_id(&mut self, v: u32) {
        self.connection_id = ::std::option::Option::Some(v);
    }

    // optional uint32 seq_num_c2r = 11;

    pub fn seq_num_c2r(&self) -> u32 {
        self.seq_num_c2r.unwrap_or(0)
    }

    pub fn clear_seq_num_c2r(&mut self) {
        self.seq_num_c2r = ::std::option::Option::None;
    }

    pub fn has_seq_num_c2r(&self) -> bool {
        self.seq_num_c2r.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seq_num_c2r(&mut self, v: u32) {
        self.seq_num_c2r = ::std::option::Option::Some(v);
    }

    // optional uint32 seq_num_e2e = 12;

    pub fn seq_num_e2e(&self) -> u32 {
        self.seq_num_e2e.unwrap_or(0)
    }

    pub fn clear_seq_num_e2e(&mut self) {
        self.seq_num_e2e = ::std::option::Option::None;
    }

    pub fn has_seq_num_e2e(&self) -> bool {
        self.seq_num_e2e.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seq_num_e2e(&mut self, v: u32) {
        self.seq_num_e2e = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CMsgSteamDatagramConnectionStatsP2PClientToRouter {
    const NAME: &'static str = "CMsgSteamDatagramConnectionStatsP2PClientToRouter";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_relay)?;
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_e2e)?;
                },
                114 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.p2p_routing_summary)?;
                },
                26 => {
                    is.read_repeated_packed_fixed32_into(&mut self.ack_relay)?;
                },
                29 => {
                    self.ack_relay.push(is.read_fixed32()?);
                },
                34 => {
                    is.read_repeated_packed_fixed32_into(&mut self.legacy_ack_e2e)?;
                },
                37 => {
                    self.legacy_ack_e2e.push(is.read_fixed32()?);
                },
                40 => {
                    self.flags = ::std::option::Option::Some(is.read_uint32()?);
                },
                50 => {
                    self.forward_target_relay_routing_token = ::std::option::Option::Some(is.read_bytes()?);
                },
                56 => {
                    self.forward_target_revision = ::std::option::Option::Some(is.read_uint32()?);
                },
                66 => {
                    self.routes = ::std::option::Option::Some(is.read_bytes()?);
                },
                72 => {
                    self.ack_peer_routes_revision = ::std::option::Option::Some(is.read_uint32()?);
                },
                85 => {
                    self.connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                88 => {
                    self.seq_num_c2r = ::std::option::Option::Some(is.read_uint32()?);
                },
                96 => {
                    self.seq_num_e2e = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.quality_relay.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.p2p_routing_summary.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += 5 * self.ack_relay.len() as u64;
        my_size += 5 * self.legacy_ack_e2e.len() as u64;
        if let Some(v) = self.flags {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.forward_target_relay_routing_token.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(6, &v);
        }
        if let Some(v) = self.forward_target_revision {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.routes.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(8, &v);
        }
        if let Some(v) = self.ack_peer_routes_revision {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
        }
        if let Some(v) = self.connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.seq_num_c2r {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(11, v);
        }
        if let Some(v) = self.seq_num_e2e {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(12, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.quality_relay.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if let Some(v) = self.p2p_routing_summary.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(14, v, os)?;
        }
        for v in &self.ack_relay {
            os.write_fixed32(3, *v)?;
        };
        for v in &self.legacy_ack_e2e {
            os.write_fixed32(4, *v)?;
        };
        if let Some(v) = self.flags {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.forward_target_relay_routing_token.as_ref() {
            os.write_bytes(6, v)?;
        }
        if let Some(v) = self.forward_target_revision {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.routes.as_ref() {
            os.write_bytes(8, v)?;
        }
        if let Some(v) = self.ack_peer_routes_revision {
            os.write_uint32(9, v)?;
        }
        if let Some(v) = self.connection_id {
            os.write_fixed32(10, v)?;
        }
        if let Some(v) = self.seq_num_c2r {
            os.write_uint32(11, v)?;
        }
        if let Some(v) = self.seq_num_e2e {
            os.write_uint32(12, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CMsgSteamDatagramConnectionStatsP2PClientToRouter {
        CMsgSteamDatagramConnectionStatsP2PClientToRouter::new()
    }

    fn clear(&mut self) {
        self.quality_relay.clear();
        self.quality_e2e.clear();
        self.p2p_routing_summary.clear();
        self.ack_relay.clear();
        self.legacy_ack_e2e.clear();
        self.flags = ::std::option::Option::None;
        self.forward_target_relay_routing_token = ::std::option::Option::None;
        self.forward_target_revision = ::std::option::Option::None;
        self.routes = ::std::option::Option::None;
        self.ack_peer_routes_revision = ::std::option::Option::None;
        self.connection_id = ::std::option::Option::None;
        self.seq_num_c2r = ::std::option::Option::None;
        self.seq_num_e2e = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramConnectionStatsP2PClientToRouter {
        static instance: CMsgSteamDatagramConnectionStatsP2PClientToRouter = CMsgSteamDatagramConnectionStatsP2PClientToRouter {
            quality_relay: ::steam_vent_proto_common::protobuf::MessageField::none(),
            quality_e2e: ::steam_vent_proto_common::protobuf::MessageField::none(),
            p2p_routing_summary: ::steam_vent_proto_common::protobuf::MessageField::none(),
            ack_relay: ::std::vec::Vec::new(),
            legacy_ack_e2e: ::std::vec::Vec::new(),
            flags: ::std::option::Option::None,
            forward_target_relay_routing_token: ::std::option::Option::None,
            forward_target_revision: ::std::option::Option::None,
            routes: ::std::option::Option::None,
            ack_peer_routes_revision: ::std::option::Option::None,
            connection_id: ::std::option::Option::None,
            seq_num_c2r: ::std::option::Option::None,
            seq_num_e2e: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CMsgSteamDatagramConnectionStatsP2PClientToRouter`
pub mod cmsg_steam_datagram_connection_stats_p2pclient_to_router {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    // @@protoc_insertion_point(enum:CMsgSteamDatagramConnectionStatsP2PClientToRouter.Flags)
    pub enum Flags {
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsP2PClientToRouter.Flags.ACK_REQUEST_RELAY)
        ACK_REQUEST_RELAY = 1,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsP2PClientToRouter.Flags.ACK_REQUEST_E2E)
        ACK_REQUEST_E2E = 2,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsP2PClientToRouter.Flags.ACK_REQUEST_IMMEDIATE)
        ACK_REQUEST_IMMEDIATE = 4,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsP2PClientToRouter.Flags.NOT_PRIMARY_SESSION)
        NOT_PRIMARY_SESSION = 8,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsP2PClientToRouter.Flags.NOT_PRIMARY_TRANSPORT_E2E)
        NOT_PRIMARY_TRANSPORT_E2E = 16,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsP2PClientToRouter.Flags.CLIENT_RELAY_OVERRIDE)
        CLIENT_RELAY_OVERRIDE = 32,
    }

    impl ::steam_vent_proto_common::protobuf::Enum for Flags {
        const NAME: &'static str = "Flags";

        fn value(&self) -> i32 {
            *self as i32
        }

        fn from_i32(value: i32) -> ::std::option::Option<Flags> {
            match value {
                1 => ::std::option::Option::Some(Flags::ACK_REQUEST_RELAY),
                2 => ::std::option::Option::Some(Flags::ACK_REQUEST_E2E),
                4 => ::std::option::Option::Some(Flags::ACK_REQUEST_IMMEDIATE),
                8 => ::std::option::Option::Some(Flags::NOT_PRIMARY_SESSION),
                16 => ::std::option::Option::Some(Flags::NOT_PRIMARY_TRANSPORT_E2E),
                32 => ::std::option::Option::Some(Flags::CLIENT_RELAY_OVERRIDE),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Flags> {
            match str {
                "ACK_REQUEST_RELAY" => ::std::option::Option::Some(Flags::ACK_REQUEST_RELAY),
                "ACK_REQUEST_E2E" => ::std::option::Option::Some(Flags::ACK_REQUEST_E2E),
                "ACK_REQUEST_IMMEDIATE" => ::std::option::Option::Some(Flags::ACK_REQUEST_IMMEDIATE),
                "NOT_PRIMARY_SESSION" => ::std::option::Option::Some(Flags::NOT_PRIMARY_SESSION),
                "NOT_PRIMARY_TRANSPORT_E2E" => ::std::option::Option::Some(Flags::NOT_PRIMARY_TRANSPORT_E2E),
                "CLIENT_RELAY_OVERRIDE" => ::std::option::Option::Some(Flags::CLIENT_RELAY_OVERRIDE),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Flags] = &[
            Flags::ACK_REQUEST_RELAY,
            Flags::ACK_REQUEST_E2E,
            Flags::ACK_REQUEST_IMMEDIATE,
            Flags::NOT_PRIMARY_SESSION,
            Flags::NOT_PRIMARY_TRANSPORT_E2E,
            Flags::CLIENT_RELAY_OVERRIDE,
        ];
    }

    // Note, `Default` is implemented although default value is not 0
    impl ::std::default::Default for Flags {
        fn default() -> Self {
            Flags::ACK_REQUEST_RELAY
        }
    }

}

// @@protoc_insertion_point(message:CMsgSteamDatagramConnectionStatsP2PRouterToClient)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramConnectionStatsP2PRouterToClient {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.quality_relay)
    pub quality_relay: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.quality_e2e)
    pub quality_e2e: ::steam_vent_proto_common::protobuf::MessageField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.seconds_until_shutdown)
    pub seconds_until_shutdown: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.migrate_request_ip)
    pub migrate_request_ip: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.migrate_request_port)
    pub migrate_request_port: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.scoring_penalty_relay_cluster)
    pub scoring_penalty_relay_cluster: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.ack_relay)
    pub ack_relay: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.legacy_ack_e2e)
    pub legacy_ack_e2e: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.flags)
    pub flags: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.ack_forward_target_revision)
    pub ack_forward_target_revision: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.routes)
    pub routes: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.ack_peer_routes_revision)
    pub ack_peer_routes_revision: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.connection_id)
    pub connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.seq_num_r2c)
    pub seq_num_r2c: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.seq_num_e2e)
    pub seq_num_e2e: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramConnectionStatsP2PRouterToClient.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CMsgSteamDatagramConnectionStatsP2PRouterToClient {
    fn default() -> &'a CMsgSteamDatagramConnectionStatsP2PRouterToClient {
        <CMsgSteamDatagramConnectionStatsP2PRouterToClient as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamDatagramConnectionStatsP2PRouterToClient {
    pub fn new() -> CMsgSteamDatagramConnectionStatsP2PRouterToClient {
        ::std::default::Default::default()
    }

    // optional uint32 seconds_until_shutdown = 3;

    pub fn seconds_until_shutdown(&self) -> u32 {
        self.seconds_until_shutdown.unwrap_or(0)
    }

    pub fn clear_seconds_until_shutdown(&mut self) {
        self.seconds_until_shutdown = ::std::option::Option::None;
    }

    pub fn has_seconds_until_shutdown(&self) -> bool {
        self.seconds_until_shutdown.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seconds_until_shutdown(&mut self, v: u32) {
        self.seconds_until_shutdown = ::std::option::Option::Some(v);
    }

    // optional fixed32 migrate_request_ip = 4;

    pub fn migrate_request_ip(&self) -> u32 {
        self.migrate_request_ip.unwrap_or(0)
    }

    pub fn clear_migrate_request_ip(&mut self) {
        self.migrate_request_ip = ::std::option::Option::None;
    }

    pub fn has_migrate_request_ip(&self) -> bool {
        self.migrate_request_ip.is_some()
    }

    // Param is passed by value, moved
    pub fn set_migrate_request_ip(&mut self, v: u32) {
        self.migrate_request_ip = ::std::option::Option::Some(v);
    }

    // optional uint32 migrate_request_port = 5;

    pub fn migrate_request_port(&self) -> u32 {
        self.migrate_request_port.unwrap_or(0)
    }

    pub fn clear_migrate_request_port(&mut self) {
        self.migrate_request_port = ::std::option::Option::None;
    }

    pub fn has_migrate_request_port(&self) -> bool {
        self.migrate_request_port.is_some()
    }

    // Param is passed by value, moved
    pub fn set_migrate_request_port(&mut self, v: u32) {
        self.migrate_request_port = ::std::option::Option::Some(v);
    }

    // optional uint32 scoring_penalty_relay_cluster = 6;

    pub fn scoring_penalty_relay_cluster(&self) -> u32 {
        self.scoring_penalty_relay_cluster.unwrap_or(0)
    }

    pub fn clear_scoring_penalty_relay_cluster(&mut self) {
        self.scoring_penalty_relay_cluster = ::std::option::Option::None;
    }

    pub fn has_scoring_penalty_relay_cluster(&self) -> bool {
        self.scoring_penalty_relay_cluster.is_some()
    }

    // Param is passed by value, moved
    pub fn set_scoring_penalty_relay_cluster(&mut self, v: u32) {
        self.scoring_penalty_relay_cluster = ::std::option::Option::Some(v);
    }

    // optional uint32 flags = 9;

    pub fn flags(&self) -> u32 {
        self.flags.unwrap_or(0)
    }

    pub fn clear_flags(&mut self) {
        self.flags = ::std::option::Option::None;
    }

    pub fn has_flags(&self) -> bool {
        self.flags.is_some()
    }

    // Param is passed by value, moved
    pub fn set_flags(&mut self, v: u32) {
        self.flags = ::std::option::Option::Some(v);
    }

    // optional uint32 ack_forward_target_revision = 10;

    pub fn ack_forward_target_revision(&self) -> u32 {
        self.ack_forward_target_revision.unwrap_or(0)
    }

    pub fn clear_ack_forward_target_revision(&mut self) {
        self.ack_forward_target_revision = ::std::option::Option::None;
    }

    pub fn has_ack_forward_target_revision(&self) -> bool {
        self.ack_forward_target_revision.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ack_forward_target_revision(&mut self, v: u32) {
        self.ack_forward_target_revision = ::std::option::Option::Some(v);
    }

    // optional bytes routes = 11;

    pub fn routes(&self) -> &[u8] {
        match self.routes.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

    pub fn clear_routes(&mut self) {
        self.routes = ::std::option::Option::None;
    }

    pub fn has_routes(&self) -> bool {
        self.routes.is_some()
    }

    // Param is passed by value, moved
    pub fn set_routes(&mut self, v: ::std::vec::Vec<u8>) {
        self.routes = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_routes(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.routes.is_none() {
            self.routes = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.routes.as_mut().unwrap()
    }

    // Take field
    pub fn take_routes(&mut self) -> ::std::vec::Vec<u8> {
        self.routes.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional uint32 ack_peer_routes_revision = 12;

    pub fn ack_peer_routes_revision(&self) -> u32 {
        self.ack_peer_routes_revision.unwrap_or(0)
    }

    pub fn clear_ack_peer_routes_revision(&mut self) {
        self.ack_peer_routes_revision = ::std::option::Option::None;
    }

    pub fn has_ack_peer_routes_revision(&self) -> bool {
        self.ack_peer_routes_revision.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ack_peer_routes_revision(&mut self, v: u32) {
        self.ack_peer_routes_revision = ::std::option::Option::Some(v);
    }

    // optional fixed32 connection_id = 13;

    pub fn connection_id(&self) -> u32 {
        self.connection_id.unwrap_or(0)
    }

    pub fn clear_connection_id(&mut self) {
        self.connection_id = ::std::option::Option::None;
    }

    pub fn has_connection_id(&self) -> bool {
        self.connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_connection_id(&mut self, v: u32) {
        self.connection_id = ::std::option::Option::Some(v);
    }

    // optional uint32 seq_num_r2c = 14;

    pub fn seq_num_r2c(&self) -> u32 {
        self.seq_num_r2c.unwrap_or(0)
    }

    pub fn clear_seq_num_r2c(&mut self) {
        self.seq_num_r2c = ::std::option::Option::None;
    }

    pub fn has_seq_num_r2c(&self) -> bool {
        self.seq_num_r2c.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seq_num_r2c(&mut self, v: u32) {
        self.seq_num_r2c = ::std::option::Option::Some(v);
    }

    // optional uint32 seq_num_e2e = 15;

    pub fn seq_num_e2e(&self) -> u32 {
        self.seq_num_e2e.unwrap_or(0)
    }

    pub fn clear_seq_num_e2e(&mut self) {
        self.seq_num_e2e = ::std::option::Option::None;
    }

    pub fn has_seq_num_e2e(&self) -> bool {
        self.seq_num_e2e.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seq_num_e2e(&mut self, v: u32) {
        self.seq_num_e2e = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CMsgSteamDatagramConnectionStatsP2PRouterToClient {
    const NAME: &'static str = "CMsgSteamDatagramConnectionStatsP2PRouterToClient";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_relay)?;
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.quality_e2e)?;
                },
                24 => {
                    self.seconds_until_shutdown = ::std::option::Option::Some(is.read_uint32()?);
                },
                37 => {
                    self.migrate_request_ip = ::std::option::Option::Some(is.read_fixed32()?);
                },
                40 => {
                    self.migrate_request_port = ::std::option::Option::Some(is.read_uint32()?);
                },
                48 => {
                    self.scoring_penalty_relay_cluster = ::std::option::Option::Some(is.read_uint32()?);
                },
                58 => {
                    is.read_repeated_packed_fixed32_into(&mut self.ack_relay)?;
                },
                61 => {
                    self.ack_relay.push(is.read_fixed32()?);
                },
                66 => {
                    is.read_repeated_packed_fixed32_into(&mut self.legacy_ack_e2e)?;
                },
                69 => {
                    self.legacy_ack_e2e.push(is.read_fixed32()?);
                },
                72 => {
                    self.flags = ::std::option::Option::Some(is.read_uint32()?);
                },
                80 => {
                    self.ack_forward_target_revision = ::std::option::Option::Some(is.read_uint32()?);
                },
                90 => {
                    self.routes = ::std::option::Option::Some(is.read_bytes()?);
                },
                96 => {
                    self.ack_peer_routes_revision = ::std::option::Option::Some(is.read_uint32()?);
                },
                109 => {
                    self.connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                112 => {
                    self.seq_num_r2c = ::std::option::Option::Some(is.read_uint32()?);
                },
                120 => {
                    self.seq_num_e2e = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.quality_relay.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.seconds_until_shutdown {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.migrate_request_ip {
            my_size += 1 + 4;
        }
        if let Some(v) = self.migrate_request_port {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.scoring_penalty_relay_cluster {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        my_size += 5 * self.ack_relay.len() as u64;
        my_size += 5 * self.legacy_ack_e2e.len() as u64;
        if let Some(v) = self.flags {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
        }
        if let Some(v) = self.ack_forward_target_revision {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(10, v);
        }
        if let Some(v) = self.routes.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(11, &v);
        }
        if let Some(v) = self.ack_peer_routes_revision {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(12, v);
        }
        if let Some(v) = self.connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.seq_num_r2c {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(14, v);
        }
        if let Some(v) = self.seq_num_e2e {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(15, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.quality_relay.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.quality_e2e.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if let Some(v) = self.seconds_until_shutdown {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.migrate_request_ip {
            os.write_fixed32(4, v)?;
        }
        if let Some(v) = self.migrate_request_port {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.scoring_penalty_relay_cluster {
            os.write_uint32(6, v)?;
        }
        for v in &self.ack_relay {
            os.write_fixed32(7, *v)?;
        };
        for v in &self.legacy_ack_e2e {
            os.write_fixed32(8, *v)?;
        };
        if let Some(v) = self.flags {
            os.write_uint32(9, v)?;
        }
        if let Some(v) = self.ack_forward_target_revision {
            os.write_uint32(10, v)?;
        }
        if let Some(v) = self.routes.as_ref() {
            os.write_bytes(11, v)?;
        }
        if let Some(v) = self.ack_peer_routes_revision {
            os.write_uint32(12, v)?;
        }
        if let Some(v) = self.connection_id {
            os.write_fixed32(13, v)?;
        }
        if let Some(v) = self.seq_num_r2c {
            os.write_uint32(14, v)?;
        }
        if let Some(v) = self.seq_num_e2e {
            os.write_uint32(15, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CMsgSteamDatagramConnectionStatsP2PRouterToClient {
        CMsgSteamDatagramConnectionStatsP2PRouterToClient::new()
    }

    fn clear(&mut self) {
        self.quality_relay.clear();
        self.quality_e2e.clear();
        self.seconds_until_shutdown = ::std::option::Option::None;
        self.migrate_request_ip = ::std::option::Option::None;
        self.migrate_request_port = ::std::option::Option::None;
        self.scoring_penalty_relay_cluster = ::std::option::Option::None;
        self.ack_relay.clear();
        self.legacy_ack_e2e.clear();
        self.flags = ::std::option::Option::None;
        self.ack_forward_target_revision = ::std::option::Option::None;
        self.routes = ::std::option::Option::None;
        self.ack_peer_routes_revision = ::std::option::Option::None;
        self.connection_id = ::std::option::Option::None;
        self.seq_num_r2c = ::std::option::Option::None;
        self.seq_num_e2e = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramConnectionStatsP2PRouterToClient {
        static instance: CMsgSteamDatagramConnectionStatsP2PRouterToClient = CMsgSteamDatagramConnectionStatsP2PRouterToClient {
            quality_relay: ::steam_vent_proto_common::protobuf::MessageField::none(),
            quality_e2e: ::steam_vent_proto_common::protobuf::MessageField::none(),
            seconds_until_shutdown: ::std::option::Option::None,
            migrate_request_ip: ::std::option::Option::None,
            migrate_request_port: ::std::option::Option::None,
            scoring_penalty_relay_cluster: ::std::option::Option::None,
            ack_relay: ::std::vec::Vec::new(),
            legacy_ack_e2e: ::std::vec::Vec::new(),
            flags: ::std::option::Option::None,
            ack_forward_target_revision: ::std::option::Option::None,
            routes: ::std::option::Option::None,
            ack_peer_routes_revision: ::std::option::Option::None,
            connection_id: ::std::option::Option::None,
            seq_num_r2c: ::std::option::Option::None,
            seq_num_e2e: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CMsgSteamDatagramConnectionStatsP2PRouterToClient`
pub mod cmsg_steam_datagram_connection_stats_p2prouter_to_client {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    // @@protoc_insertion_point(enum:CMsgSteamDatagramConnectionStatsP2PRouterToClient.Flags)
    pub enum Flags {
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsP2PRouterToClient.Flags.ACK_REQUEST_RELAY)
        ACK_REQUEST_RELAY = 1,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsP2PRouterToClient.Flags.ACK_REQUEST_E2E)
        ACK_REQUEST_E2E = 2,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsP2PRouterToClient.Flags.ACK_REQUEST_IMMEDIATE)
        ACK_REQUEST_IMMEDIATE = 4,
        // @@protoc_insertion_point(enum_value:CMsgSteamDatagramConnectionStatsP2PRouterToClient.Flags.NOT_PRIMARY_TRANSPORT_E2E)
        NOT_PRIMARY_TRANSPORT_E2E = 16,
    }

    impl ::steam_vent_proto_common::protobuf::Enum for Flags {
        const NAME: &'static str = "Flags";

        fn value(&self) -> i32 {
            *self as i32
        }

        fn from_i32(value: i32) -> ::std::option::Option<Flags> {
            match value {
                1 => ::std::option::Option::Some(Flags::ACK_REQUEST_RELAY),
                2 => ::std::option::Option::Some(Flags::ACK_REQUEST_E2E),
                4 => ::std::option::Option::Some(Flags::ACK_REQUEST_IMMEDIATE),
                16 => ::std::option::Option::Some(Flags::NOT_PRIMARY_TRANSPORT_E2E),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Flags> {
            match str {
                "ACK_REQUEST_RELAY" => ::std::option::Option::Some(Flags::ACK_REQUEST_RELAY),
                "ACK_REQUEST_E2E" => ::std::option::Option::Some(Flags::ACK_REQUEST_E2E),
                "ACK_REQUEST_IMMEDIATE" => ::std::option::Option::Some(Flags::ACK_REQUEST_IMMEDIATE),
                "NOT_PRIMARY_TRANSPORT_E2E" => ::std::option::Option::Some(Flags::NOT_PRIMARY_TRANSPORT_E2E),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Flags] = &[
            Flags::ACK_REQUEST_RELAY,
            Flags::ACK_REQUEST_E2E,
            Flags::ACK_REQUEST_IMMEDIATE,
            Flags::NOT_PRIMARY_TRANSPORT_E2E,
        ];
    }

    // Note, `Default` is implemented although default value is not 0
    impl ::std::default::Default for Flags {
        fn default() -> Self {
            Flags::ACK_REQUEST_RELAY
        }
    }

}

// @@protoc_insertion_point(message:CMsgSteamDatagramP2PBadRouteRouterToClient)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramP2PBadRouteRouterToClient {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PBadRouteRouterToClient.connection_id)
    pub connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PBadRouteRouterToClient.failed_relay_routing_token)
    pub failed_relay_routing_token: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PBadRouteRouterToClient.ack_forward_target_revision)
    pub ack_forward_target_revision: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PBadRouteRouterToClient.kludge_pad)
    pub kludge_pad: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramP2PBadRouteRouterToClient.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CMsgSteamDatagramP2PBadRouteRouterToClient {
    fn default() -> &'a CMsgSteamDatagramP2PBadRouteRouterToClient {
        <CMsgSteamDatagramP2PBadRouteRouterToClient as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamDatagramP2PBadRouteRouterToClient {
    pub fn new() -> CMsgSteamDatagramP2PBadRouteRouterToClient {
        ::std::default::Default::default()
    }

    // optional fixed32 connection_id = 1;

    pub fn connection_id(&self) -> u32 {
        self.connection_id.unwrap_or(0)
    }

    pub fn clear_connection_id(&mut self) {
        self.connection_id = ::std::option::Option::None;
    }

    pub fn has_connection_id(&self) -> bool {
        self.connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_connection_id(&mut self, v: u32) {
        self.connection_id = ::std::option::Option::Some(v);
    }

    // optional bytes failed_relay_routing_token = 2;

    pub fn failed_relay_routing_token(&self) -> &[u8] {
        match self.failed_relay_routing_token.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

    pub fn clear_failed_relay_routing_token(&mut self) {
        self.failed_relay_routing_token = ::std::option::Option::None;
    }

    pub fn has_failed_relay_routing_token(&self) -> bool {
        self.failed_relay_routing_token.is_some()
    }

    // Param is passed by value, moved
    pub fn set_failed_relay_routing_token(&mut self, v: ::std::vec::Vec<u8>) {
        self.failed_relay_routing_token = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_failed_relay_routing_token(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.failed_relay_routing_token.is_none() {
            self.failed_relay_routing_token = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.failed_relay_routing_token.as_mut().unwrap()
    }

    // Take field
    pub fn take_failed_relay_routing_token(&mut self) -> ::std::vec::Vec<u8> {
        self.failed_relay_routing_token.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional uint32 ack_forward_target_revision = 3;

    pub fn ack_forward_target_revision(&self) -> u32 {
        self.ack_forward_target_revision.unwrap_or(0)
    }

    pub fn clear_ack_forward_target_revision(&mut self) {
        self.ack_forward_target_revision = ::std::option::Option::None;
    }

    pub fn has_ack_forward_target_revision(&self) -> bool {
        self.ack_forward_target_revision.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ack_forward_target_revision(&mut self, v: u32) {
        self.ack_forward_target_revision = ::std::option::Option::Some(v);
    }

    // optional fixed64 kludge_pad = 99;

    pub fn kludge_pad(&self) -> u64 {
        self.kludge_pad.unwrap_or(0)
    }

    pub fn clear_kludge_pad(&mut self) {
        self.kludge_pad = ::std::option::Option::None;
    }

    pub fn has_kludge_pad(&self) -> bool {
        self.kludge_pad.is_some()
    }

    // Param is passed by value, moved
    pub fn set_kludge_pad(&mut self, v: u64) {
        self.kludge_pad = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CMsgSteamDatagramP2PBadRouteRouterToClient {
    const NAME: &'static str = "CMsgSteamDatagramP2PBadRouteRouterToClient";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                13 => {
                    self.connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                18 => {
                    self.failed_relay_routing_token = ::std::option::Option::Some(is.read_bytes()?);
                },
                24 => {
                    self.ack_forward_target_revision = ::std::option::Option::Some(is.read_uint32()?);
                },
                793 => {
                    self.kludge_pad = ::std::option::Option::Some(is.read_fixed64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.failed_relay_routing_token.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(v) = self.ack_forward_target_revision {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.kludge_pad {
            my_size += 2 + 8;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.connection_id {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.failed_relay_routing_token.as_ref() {
            os.write_bytes(2, v)?;
        }
        if let Some(v) = self.ack_forward_target_revision {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.kludge_pad {
            os.write_fixed64(99, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CMsgSteamDatagramP2PBadRouteRouterToClient {
        CMsgSteamDatagramP2PBadRouteRouterToClient::new()
    }

    fn clear(&mut self) {
        self.connection_id = ::std::option::Option::None;
        self.failed_relay_routing_token = ::std::option::Option::None;
        self.ack_forward_target_revision = ::std::option::Option::None;
        self.kludge_pad = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramP2PBadRouteRouterToClient {
        static instance: CMsgSteamDatagramP2PBadRouteRouterToClient = CMsgSteamDatagramP2PBadRouteRouterToClient {
            connection_id: ::std::option::Option::None,
            failed_relay_routing_token: ::std::option::Option::None,
            ack_forward_target_revision: ::std::option::Option::None,
            kludge_pad: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramP2PRoutes)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramP2PRoutes {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PRoutes.relay_clusters)
    pub relay_clusters: ::std::vec::Vec<cmsg_steam_datagram_p2proutes::RelayCluster>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PRoutes.routes)
    pub routes: ::std::vec::Vec<cmsg_steam_datagram_p2proutes::Route>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramP2PRoutes.revision)
    pub revision: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramP2PRoutes.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CMsgSteamDatagramP2PRoutes {
    fn default() -> &'a CMsgSteamDatagramP2PRoutes {
        <CMsgSteamDatagramP2PRoutes as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamDatagramP2PRoutes {
    pub fn new() -> CMsgSteamDatagramP2PRoutes {
        ::std::default::Default::default()
    }

    // optional uint32 revision = 3;

    pub fn revision(&self) -> u32 {
        self.revision.unwrap_or(0)
    }

    pub fn clear_revision(&mut self) {
        self.revision = ::std::option::Option::None;
    }

    pub fn has_revision(&self) -> bool {
        self.revision.is_some()
    }

    // Param is passed by value, moved
    pub fn set_revision(&mut self, v: u32) {
        self.revision = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CMsgSteamDatagramP2PRoutes {
    const NAME: &'static str = "CMsgSteamDatagramP2PRoutes";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.relay_clusters.push(is.read_message()?);
                },
                18 => {
                    self.routes.push(is.read_message()?);
                },
                24 => {
                    self.revision = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.relay_clusters {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.routes {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.revision {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.relay_clusters {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        for v in &self.routes {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        if let Some(v) = self.revision {
            os.write_uint32(3, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CMsgSteamDatagramP2PRoutes {
        CMsgSteamDatagramP2PRoutes::new()
    }

    fn clear(&mut self) {
        self.relay_clusters.clear();
        self.routes.clear();
        self.revision = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramP2PRoutes {
        static instance: CMsgSteamDatagramP2PRoutes = CMsgSteamDatagramP2PRoutes {
            relay_clusters: ::std::vec::Vec::new(),
            routes: ::std::vec::Vec::new(),
            revision: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CMsgSteamDatagramP2PRoutes`
pub mod cmsg_steam_datagram_p2proutes {
    // @@protoc_insertion_point(message:CMsgSteamDatagramP2PRoutes.RelayCluster)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct RelayCluster {
        // message fields
        // @@protoc_insertion_point(field:CMsgSteamDatagramP2PRoutes.RelayCluster.pop_id)
        pub pop_id: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramP2PRoutes.RelayCluster.ping_ms)
        pub ping_ms: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramP2PRoutes.RelayCluster.score_penalty)
        pub score_penalty: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramP2PRoutes.RelayCluster.session_relay_routing_token)
        pub session_relay_routing_token: ::std::option::Option<::std::vec::Vec<u8>>,
        // special fields
        // @@protoc_insertion_point(special_field:CMsgSteamDatagramP2PRoutes.RelayCluster.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

    impl<'a> ::std::default::Default for &'a RelayCluster {
        fn default() -> &'a RelayCluster {
            <RelayCluster as ::steam_vent_proto_common::protobuf::Message>::default_instance()
        }
    }

    impl RelayCluster {
        pub fn new() -> RelayCluster {
            ::std::default::Default::default()
        }

        // optional fixed32 pop_id = 1;

        pub fn pop_id(&self) -> u32 {
            self.pop_id.unwrap_or(0)
        }

        pub fn clear_pop_id(&mut self) {
            self.pop_id = ::std::option::Option::None;
        }

        pub fn has_pop_id(&self) -> bool {
            self.pop_id.is_some()
        }

        // Param is passed by value, moved
        pub fn set_pop_id(&mut self, v: u32) {
            self.pop_id = ::std::option::Option::Some(v);
        }

        // optional uint32 ping_ms = 2;

        pub fn ping_ms(&self) -> u32 {
            self.ping_ms.unwrap_or(0)
        }

        pub fn clear_ping_ms(&mut self) {
            self.ping_ms = ::std::option::Option::None;
        }

        pub fn has_ping_ms(&self) -> bool {
            self.ping_ms.is_some()
        }

        // Param is passed by value, moved
        pub fn set_ping_ms(&mut self, v: u32) {
            self.ping_ms = ::std::option::Option::Some(v);
        }

        // optional uint32 score_penalty = 3;

        pub fn score_penalty(&self) -> u32 {
            self.score_penalty.unwrap_or(0)
        }

        pub fn clear_score_penalty(&mut self) {
            self.score_penalty = ::std::option::Option::None;
        }

        pub fn has_score_penalty(&self) -> bool {
            self.score_penalty.is_some()
        }

        // Param is passed by value, moved
        pub fn set_score_penalty(&mut self, v: u32) {
            self.score_penalty = ::std::option::Option::Some(v);
        }

        // optional bytes session_relay_routing_token = 4;

        pub fn session_relay_routing_token(&self) -> &[u8] {
            match self.session_relay_routing_token.as_ref() {
                Some(v) => v,
                None => &[],
            }
        }

        pub fn clear_session_relay_routing_token(&mut self) {
            self.session_relay_routing_token = ::std::option::Option::None;
        }

        pub fn has_session_relay_routing_token(&self) -> bool {
            self.session_relay_routing_token.is_some()
        }

        // Param is passed by value, moved
        pub fn set_session_relay_routing_token(&mut self, v: ::std::vec::Vec<u8>) {
            self.session_relay_routing_token = ::std::option::Option::Some(v);
        }

        // Mutable pointer to the field.
        // If field is not initialized, it is initialized with default value first.
        pub fn mut_session_relay_routing_token(&mut self) -> &mut ::std::vec::Vec<u8> {
            if self.session_relay_routing_token.is_none() {
                self.session_relay_routing_token = ::std::option::Option::Some(::std::vec::Vec::new());
            }
            self.session_relay_routing_token.as_mut().unwrap()
        }

        // Take field
        pub fn take_session_relay_routing_token(&mut self) -> ::std::vec::Vec<u8> {
            self.session_relay_routing_token.take().unwrap_or_else(|| ::std::vec::Vec::new())
        }
    }

    impl ::steam_vent_proto_common::protobuf::Message for RelayCluster {
        const NAME: &'static str = "RelayCluster";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    13 => {
                        self.pop_id = ::std::option::Option::Some(is.read_fixed32()?);
                    },
                    16 => {
                        self.ping_ms = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    24 => {
                        self.score_penalty = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    34 => {
                        self.session_relay_routing_token = ::std::option::Option::Some(is.read_bytes()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if let Some(v) = self.pop_id {
                my_size += 1 + 4;
            }
            if let Some(v) = self.ping_ms {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
            }
            if let Some(v) = self.score_penalty {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
            }
            if let Some(v) = self.session_relay_routing_token.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(4, &v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.pop_id {
                os.write_fixed32(1, v)?;
            }
            if let Some(v) = self.ping_ms {
                os.write_uint32(2, v)?;
            }
            if let Some(v) = self.score_penalty {
                os.write_uint32(3, v)?;
            }
            if let Some(v) = self.session_relay_routing_token.as_ref() {
                os.write_bytes(4, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
            &mut self.special_fields
        }

        fn new() -> RelayCluster {
            RelayCluster::new()
        }

        fn clear(&mut self) {
            self.pop_id = ::std::option::Option::None;
            self.ping_ms = ::std::option::Option::None;
            self.score_penalty = ::std::option::Option::None;
            self.session_relay_routing_token = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static RelayCluster {
            static instance: RelayCluster = RelayCluster {
                pop_id: ::std::option::Option::None,
                ping_ms: ::std::option::Option::None,
                score_penalty: ::std::option::Option::None,
                session_relay_routing_token: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:CMsgSteamDatagramP2PRoutes.Route)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Route {
        // message fields
        // @@protoc_insertion_point(field:CMsgSteamDatagramP2PRoutes.Route.my_pop_id)
        pub my_pop_id: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramP2PRoutes.Route.your_pop_id)
        pub your_pop_id: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramP2PRoutes.Route.legacy_score)
        pub legacy_score: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramP2PRoutes.Route.interior_score)
        pub interior_score: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CMsgSteamDatagramP2PRoutes.Route.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

    impl<'a> ::std::default::Default for &'a Route {
        fn default() -> &'a Route {
            <Route as ::steam_vent_proto_common::protobuf::Message>::default_instance()
        }
    }

    impl Route {
        pub fn new() -> Route {
            ::std::default::Default::default()
        }

        // optional fixed32 my_pop_id = 1;

        pub fn my_pop_id(&self) -> u32 {
            self.my_pop_id.unwrap_or(0)
        }

        pub fn clear_my_pop_id(&mut self) {
            self.my_pop_id = ::std::option::Option::None;
        }

        pub fn has_my_pop_id(&self) -> bool {
            self.my_pop_id.is_some()
        }

        // Param is passed by value, moved
        pub fn set_my_pop_id(&mut self, v: u32) {
            self.my_pop_id = ::std::option::Option::Some(v);
        }

        // optional fixed32 your_pop_id = 2;

        pub fn your_pop_id(&self) -> u32 {
            self.your_pop_id.unwrap_or(0)
        }

        pub fn clear_your_pop_id(&mut self) {
            self.your_pop_id = ::std::option::Option::None;
        }

        pub fn has_your_pop_id(&self) -> bool {
            self.your_pop_id.is_some()
        }

        // Param is passed by value, moved
        pub fn set_your_pop_id(&mut self, v: u32) {
            self.your_pop_id = ::std::option::Option::Some(v);
        }

        // optional uint32 legacy_score = 3;

        pub fn legacy_score(&self) -> u32 {
            self.legacy_score.unwrap_or(0)
        }

        pub fn clear_legacy_score(&mut self) {
            self.legacy_score = ::std::option::Option::None;
        }

        pub fn has_legacy_score(&self) -> bool {
            self.legacy_score.is_some()
        }

        // Param is passed by value, moved
        pub fn set_legacy_score(&mut self, v: u32) {
            self.legacy_score = ::std::option::Option::Some(v);
        }

        // optional uint32 interior_score = 4;

        pub fn interior_score(&self) -> u32 {
            self.interior_score.unwrap_or(0)
        }

        pub fn clear_interior_score(&mut self) {
            self.interior_score = ::std::option::Option::None;
        }

        pub fn has_interior_score(&self) -> bool {
            self.interior_score.is_some()
        }

        // Param is passed by value, moved
        pub fn set_interior_score(&mut self, v: u32) {
            self.interior_score = ::std::option::Option::Some(v);
        }
    }

    impl ::steam_vent_proto_common::protobuf::Message for Route {
        const NAME: &'static str = "Route";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    13 => {
                        self.my_pop_id = ::std::option::Option::Some(is.read_fixed32()?);
                    },
                    21 => {
                        self.your_pop_id = ::std::option::Option::Some(is.read_fixed32()?);
                    },
                    24 => {
                        self.legacy_score = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    32 => {
                        self.interior_score = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if let Some(v) = self.my_pop_id {
                my_size += 1 + 4;
            }
            if let Some(v) = self.your_pop_id {
                my_size += 1 + 4;
            }
            if let Some(v) = self.legacy_score {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
            }
            if let Some(v) = self.interior_score {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.my_pop_id {
                os.write_fixed32(1, v)?;
            }
            if let Some(v) = self.your_pop_id {
                os.write_fixed32(2, v)?;
            }
            if let Some(v) = self.legacy_score {
                os.write_uint32(3, v)?;
            }
            if let Some(v) = self.interior_score {
                os.write_uint32(4, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
            &mut self.special_fields
        }

        fn new() -> Route {
            Route::new()
        }

        fn clear(&mut self) {
            self.my_pop_id = ::std::option::Option::None;
            self.your_pop_id = ::std::option::Option::None;
            self.legacy_score = ::std::option::Option::None;
            self.interior_score = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Route {
            static instance: Route = Route {
                my_pop_id: ::std::option::Option::None,
                your_pop_id: ::std::option::Option::None,
                legacy_score: ::std::option::Option::None,
                interior_score: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramSetSecondaryAddressRequest)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramSetSecondaryAddressRequest {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramSetSecondaryAddressRequest.client_main_ip)
    pub client_main_ip: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramSetSecondaryAddressRequest.client_main_port)
    pub client_main_port: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramSetSecondaryAddressRequest.client_connection_id)
    pub client_connection_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramSetSecondaryAddressRequest.client_identity)
    pub client_identity: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramSetSecondaryAddressRequest.request_send_duplication)
    pub request_send_duplication: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramSetSecondaryAddressRequest.kludge_pad)
    pub kludge_pad: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramSetSecondaryAddressRequest.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CMsgSteamDatagramSetSecondaryAddressRequest {
    fn default() -> &'a CMsgSteamDatagramSetSecondaryAddressRequest {
        <CMsgSteamDatagramSetSecondaryAddressRequest as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamDatagramSetSecondaryAddressRequest {
    pub fn new() -> CMsgSteamDatagramSetSecondaryAddressRequest {
        ::std::default::Default::default()
    }

    // optional fixed32 client_main_ip = 1;

    pub fn client_main_ip(&self) -> u32 {
        self.client_main_ip.unwrap_or(0)
    }

    pub fn clear_client_main_ip(&mut self) {
        self.client_main_ip = ::std::option::Option::None;
    }

    pub fn has_client_main_ip(&self) -> bool {
        self.client_main_ip.is_some()
    }

    // Param is passed by value, moved
    pub fn set_client_main_ip(&mut self, v: u32) {
        self.client_main_ip = ::std::option::Option::Some(v);
    }

    // optional fixed32 client_main_port = 2;

    pub fn client_main_port(&self) -> u32 {
        self.client_main_port.unwrap_or(0)
    }

    pub fn clear_client_main_port(&mut self) {
        self.client_main_port = ::std::option::Option::None;
    }

    pub fn has_client_main_port(&self) -> bool {
        self.client_main_port.is_some()
    }

    // Param is passed by value, moved
    pub fn set_client_main_port(&mut self, v: u32) {
        self.client_main_port = ::std::option::Option::Some(v);
    }

    // optional fixed32 client_connection_id = 3;

    pub fn client_connection_id(&self) -> u32 {
        self.client_connection_id.unwrap_or(0)
    }

    pub fn clear_client_connection_id(&mut self) {
        self.client_connection_id = ::std::option::Option::None;
    }

    pub fn has_client_connection_id(&self) -> bool {
        self.client_connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_client_connection_id(&mut self, v: u32) {
        self.client_connection_id = ::std::option::Option::Some(v);
    }

    // optional string client_identity = 4;

    pub fn client_identity(&self) -> &str {
        match self.client_identity.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_client_identity(&mut self) {
        self.client_identity = ::std::option::Option::None;
    }

    pub fn has_client_identity(&self) -> bool {
        self.client_identity.is_some()
    }

    // Param is passed by value, moved
    pub fn set_client_identity(&mut self, v: ::std::string::String) {
        self.client_identity = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_client_identity(&mut self) -> &mut ::std::string::String {
        if self.client_identity.is_none() {
            self.client_identity = ::std::option::Option::Some(::std::string::String::new());
        }
        self.client_identity.as_mut().unwrap()
    }

    // Take field
    pub fn take_client_identity(&mut self) -> ::std::string::String {
        self.client_identity.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional bool request_send_duplication = 5;

    pub fn request_send_duplication(&self) -> bool {
        self.request_send_duplication.unwrap_or(false)
    }

    pub fn clear_request_send_duplication(&mut self) {
        self.request_send_duplication = ::std::option::Option::None;
    }

    pub fn has_request_send_duplication(&self) -> bool {
        self.request_send_duplication.is_some()
    }

    // Param is passed by value, moved
    pub fn set_request_send_duplication(&mut self, v: bool) {
        self.request_send_duplication = ::std::option::Option::Some(v);
    }

    // optional bytes kludge_pad = 99;

    pub fn kludge_pad(&self) -> &[u8] {
        match self.kludge_pad.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

    pub fn clear_kludge_pad(&mut self) {
        self.kludge_pad = ::std::option::Option::None;
    }

    pub fn has_kludge_pad(&self) -> bool {
        self.kludge_pad.is_some()
    }

    // Param is passed by value, moved
    pub fn set_kludge_pad(&mut self, v: ::std::vec::Vec<u8>) {
        self.kludge_pad = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_kludge_pad(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.kludge_pad.is_none() {
            self.kludge_pad = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.kludge_pad.as_mut().unwrap()
    }

    // Take field
    pub fn take_kludge_pad(&mut self) -> ::std::vec::Vec<u8> {
        self.kludge_pad.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CMsgSteamDatagramSetSecondaryAddressRequest {
    const NAME: &'static str = "CMsgSteamDatagramSetSecondaryAddressRequest";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                13 => {
                    self.client_main_ip = ::std::option::Option::Some(is.read_fixed32()?);
                },
                21 => {
                    self.client_main_port = ::std::option::Option::Some(is.read_fixed32()?);
                },
                29 => {
                    self.client_connection_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                34 => {
                    self.client_identity = ::std::option::Option::Some(is.read_string()?);
                },
                40 => {
                    self.request_send_duplication = ::std::option::Option::Some(is.read_bool()?);
                },
                794 => {
                    self.kludge_pad = ::std::option::Option::Some(is.read_bytes()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.client_main_ip {
            my_size += 1 + 4;
        }
        if let Some(v) = self.client_main_port {
            my_size += 1 + 4;
        }
        if let Some(v) = self.client_connection_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.client_identity.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.request_send_duplication {
            my_size += 1 + 1;
        }
        if let Some(v) = self.kludge_pad.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(99, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.client_main_ip {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.client_main_port {
            os.write_fixed32(2, v)?;
        }
        if let Some(v) = self.client_connection_id {
            os.write_fixed32(3, v)?;
        }
        if let Some(v) = self.client_identity.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.request_send_duplication {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.kludge_pad.as_ref() {
            os.write_bytes(99, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CMsgSteamDatagramSetSecondaryAddressRequest {
        CMsgSteamDatagramSetSecondaryAddressRequest::new()
    }

    fn clear(&mut self) {
        self.client_main_ip = ::std::option::Option::None;
        self.client_main_port = ::std::option::Option::None;
        self.client_connection_id = ::std::option::Option::None;
        self.client_identity = ::std::option::Option::None;
        self.request_send_duplication = ::std::option::Option::None;
        self.kludge_pad = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramSetSecondaryAddressRequest {
        static instance: CMsgSteamDatagramSetSecondaryAddressRequest = CMsgSteamDatagramSetSecondaryAddressRequest {
            client_main_ip: ::std::option::Option::None,
            client_main_port: ::std::option::Option::None,
            client_connection_id: ::std::option::Option::None,
            client_identity: ::std::option::Option::None,
            request_send_duplication: ::std::option::Option::None,
            kludge_pad: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramSetSecondaryAddressResult)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramSetSecondaryAddressResult {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramSetSecondaryAddressResult.success)
    pub success: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramSetSecondaryAddressResult.message)
    pub message: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramSetSecondaryAddressResult.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CMsgSteamDatagramSetSecondaryAddressResult {
    fn default() -> &'a CMsgSteamDatagramSetSecondaryAddressResult {
        <CMsgSteamDatagramSetSecondaryAddressResult as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamDatagramSetSecondaryAddressResult {
    pub fn new() -> CMsgSteamDatagramSetSecondaryAddressResult {
        ::std::default::Default::default()
    }

    // optional bool success = 1;

    pub fn success(&self) -> bool {
        self.success.unwrap_or(false)
    }

    pub fn clear_success(&mut self) {
        self.success = ::std::option::Option::None;
    }

    pub fn has_success(&self) -> bool {
        self.success.is_some()
    }

    // Param is passed by value, moved
    pub fn set_success(&mut self, v: bool) {
        self.success = ::std::option::Option::Some(v);
    }

    // optional string message = 2;

    pub fn message(&self) -> &str {
        match self.message.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_message(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_message(&self) -> bool {
        self.message.is_some()
    }

    // Param is passed by value, moved
    pub fn set_message(&mut self, v: ::std::string::String) {
        self.message = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_message(&mut self) -> &mut ::std::string::String {
        if self.message.is_none() {
            self.message = ::std::option::Option::Some(::std::string::String::new());
        }
        self.message.as_mut().unwrap()
    }

    // Take field
    pub fn take_message(&mut self) -> ::std::string::String {
        self.message.take().unwrap_or_else(|| ::std::string::String::new())
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CMsgSteamDatagramSetSecondaryAddressResult {
    const NAME: &'static str = "CMsgSteamDatagramSetSecondaryAddressResult";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.success = ::std::option::Option::Some(is.read_bool()?);
                },
                18 => {
                    self.message = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.success {
            my_size += 1 + 1;
        }
        if let Some(v) = self.message.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.success {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.message.as_ref() {
            os.write_string(2, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CMsgSteamDatagramSetSecondaryAddressResult {
        CMsgSteamDatagramSetSecondaryAddressResult::new()
    }

    fn clear(&mut self) {
        self.success = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramSetSecondaryAddressResult {
        static instance: CMsgSteamDatagramSetSecondaryAddressResult = CMsgSteamDatagramSetSecondaryAddressResult {
            success: ::std::option::Option::None,
            message: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:ESteamDatagramMsgID)
pub enum ESteamDatagramMsgID {
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_Invalid)
    k_ESteamDatagramMsg_Invalid = 0,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_RouterPingRequest)
    k_ESteamDatagramMsg_RouterPingRequest = 1,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_RouterPingReply)
    k_ESteamDatagramMsg_RouterPingReply = 2,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_GameserverPingRequest)
    k_ESteamDatagramMsg_GameserverPingRequest = 3,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_GameserverSessionRequest)
    k_ESteamDatagramMsg_GameserverSessionRequest = 5,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_GameserverSessionEstablished)
    k_ESteamDatagramMsg_GameserverSessionEstablished = 6,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_NoSession)
    k_ESteamDatagramMsg_NoSession = 7,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_Diagnostic)
    k_ESteamDatagramMsg_Diagnostic = 8,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_DataClientToRouter)
    k_ESteamDatagramMsg_DataClientToRouter = 9,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_DataRouterToServer)
    k_ESteamDatagramMsg_DataRouterToServer = 10,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_DataServerToRouter)
    k_ESteamDatagramMsg_DataServerToRouter = 11,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_DataRouterToClient)
    k_ESteamDatagramMsg_DataRouterToClient = 12,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_Stats)
    k_ESteamDatagramMsg_Stats = 13,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_ClientPingSampleRequest)
    k_ESteamDatagramMsg_ClientPingSampleRequest = 14,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_ClientPingSampleReply)
    k_ESteamDatagramMsg_ClientPingSampleReply = 15,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_ClientToRouterSwitchedPrimary)
    k_ESteamDatagramMsg_ClientToRouterSwitchedPrimary = 16,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_RelayHealth)
    k_ESteamDatagramMsg_RelayHealth = 17,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_ConnectRequest)
    k_ESteamDatagramMsg_ConnectRequest = 18,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_ConnectOK)
    k_ESteamDatagramMsg_ConnectOK = 19,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_ConnectionClosed)
    k_ESteamDatagramMsg_ConnectionClosed = 20,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_NoConnection)
    k_ESteamDatagramMsg_NoConnection = 21,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_TicketDecryptRequest)
    k_ESteamDatagramMsg_TicketDecryptRequest = 22,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_TicketDecryptReply)
    k_ESteamDatagramMsg_TicketDecryptReply = 23,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_P2PSessionRequest)
    k_ESteamDatagramMsg_P2PSessionRequest = 24,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_P2PSessionEstablished)
    k_ESteamDatagramMsg_P2PSessionEstablished = 25,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_P2PStatsClient)
    k_ESteamDatagramMsg_P2PStatsClient = 26,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_P2PStatsRelay)
    k_ESteamDatagramMsg_P2PStatsRelay = 27,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_P2PBadRoute)
    k_ESteamDatagramMsg_P2PBadRoute = 28,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_GameserverPingReply)
    k_ESteamDatagramMsg_GameserverPingReply = 29,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_LegacyGameserverRegistration)
    k_ESteamDatagramMsg_LegacyGameserverRegistration = 30,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_SetSecondaryAddressRequest)
    k_ESteamDatagramMsg_SetSecondaryAddressRequest = 31,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_SetSecondaryAddressResult)
    k_ESteamDatagramMsg_SetSecondaryAddressResult = 32,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_RelayToRelayPingRequest)
    k_ESteamDatagramMsg_RelayToRelayPingRequest = 33,
    // @@protoc_insertion_point(enum_value:ESteamDatagramMsgID.k_ESteamDatagramMsg_RelayToRelayPingReply)
    k_ESteamDatagramMsg_RelayToRelayPingReply = 34,
}

impl ::steam_vent_proto_common::protobuf::Enum for ESteamDatagramMsgID {
    const NAME: &'static str = "ESteamDatagramMsgID";

    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<ESteamDatagramMsgID> {
        match value {
            0 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_Invalid),
            1 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_RouterPingRequest),
            2 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_RouterPingReply),
            3 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_GameserverPingRequest),
            5 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_GameserverSessionRequest),
            6 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_GameserverSessionEstablished),
            7 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_NoSession),
            8 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_Diagnostic),
            9 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_DataClientToRouter),
            10 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_DataRouterToServer),
            11 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_DataServerToRouter),
            12 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_DataRouterToClient),
            13 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_Stats),
            14 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_ClientPingSampleRequest),
            15 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_ClientPingSampleReply),
            16 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_ClientToRouterSwitchedPrimary),
            17 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_RelayHealth),
            18 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_ConnectRequest),
            19 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_ConnectOK),
            20 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_ConnectionClosed),
            21 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_NoConnection),
            22 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_TicketDecryptRequest),
            23 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_TicketDecryptReply),
            24 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_P2PSessionRequest),
            25 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_P2PSessionEstablished),
            26 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_P2PStatsClient),
            27 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_P2PStatsRelay),
            28 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_P2PBadRoute),
            29 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_GameserverPingReply),
            30 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_LegacyGameserverRegistration),
            31 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_SetSecondaryAddressRequest),
            32 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_SetSecondaryAddressResult),
            33 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_RelayToRelayPingRequest),
            34 => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_RelayToRelayPingReply),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<ESteamDatagramMsgID> {
        match str {
            "k_ESteamDatagramMsg_Invalid" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_Invalid),
            "k_ESteamDatagramMsg_RouterPingRequest" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_RouterPingRequest),
            "k_ESteamDatagramMsg_RouterPingReply" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_RouterPingReply),
            "k_ESteamDatagramMsg_GameserverPingRequest" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_GameserverPingRequest),
            "k_ESteamDatagramMsg_GameserverSessionRequest" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_GameserverSessionRequest),
            "k_ESteamDatagramMsg_GameserverSessionEstablished" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_GameserverSessionEstablished),
            "k_ESteamDatagramMsg_NoSession" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_NoSession),
            "k_ESteamDatagramMsg_Diagnostic" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_Diagnostic),
            "k_ESteamDatagramMsg_DataClientToRouter" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_DataClientToRouter),
            "k_ESteamDatagramMsg_DataRouterToServer" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_DataRouterToServer),
            "k_ESteamDatagramMsg_DataServerToRouter" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_DataServerToRouter),
            "k_ESteamDatagramMsg_DataRouterToClient" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_DataRouterToClient),
            "k_ESteamDatagramMsg_Stats" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_Stats),
            "k_ESteamDatagramMsg_ClientPingSampleRequest" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_ClientPingSampleRequest),
            "k_ESteamDatagramMsg_ClientPingSampleReply" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_ClientPingSampleReply),
            "k_ESteamDatagramMsg_ClientToRouterSwitchedPrimary" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_ClientToRouterSwitchedPrimary),
            "k_ESteamDatagramMsg_RelayHealth" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_RelayHealth),
            "k_ESteamDatagramMsg_ConnectRequest" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_ConnectRequest),
            "k_ESteamDatagramMsg_ConnectOK" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_ConnectOK),
            "k_ESteamDatagramMsg_ConnectionClosed" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_ConnectionClosed),
            "k_ESteamDatagramMsg_NoConnection" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_NoConnection),
            "k_ESteamDatagramMsg_TicketDecryptRequest" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_TicketDecryptRequest),
            "k_ESteamDatagramMsg_TicketDecryptReply" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_TicketDecryptReply),
            "k_ESteamDatagramMsg_P2PSessionRequest" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_P2PSessionRequest),
            "k_ESteamDatagramMsg_P2PSessionEstablished" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_P2PSessionEstablished),
            "k_ESteamDatagramMsg_P2PStatsClient" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_P2PStatsClient),
            "k_ESteamDatagramMsg_P2PStatsRelay" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_P2PStatsRelay),
            "k_ESteamDatagramMsg_P2PBadRoute" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_P2PBadRoute),
            "k_ESteamDatagramMsg_GameserverPingReply" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_GameserverPingReply),
            "k_ESteamDatagramMsg_LegacyGameserverRegistration" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_LegacyGameserverRegistration),
            "k_ESteamDatagramMsg_SetSecondaryAddressRequest" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_SetSecondaryAddressRequest),
            "k_ESteamDatagramMsg_SetSecondaryAddressResult" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_SetSecondaryAddressResult),
            "k_ESteamDatagramMsg_RelayToRelayPingRequest" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_RelayToRelayPingRequest),
            "k_ESteamDatagramMsg_RelayToRelayPingReply" => ::std::option::Option::Some(ESteamDatagramMsgID::k_ESteamDatagramMsg_RelayToRelayPingReply),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [ESteamDatagramMsgID] = &[
        ESteamDatagramMsgID::k_ESteamDatagramMsg_Invalid,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_RouterPingRequest,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_RouterPingReply,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_GameserverPingRequest,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_GameserverSessionRequest,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_GameserverSessionEstablished,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_NoSession,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_Diagnostic,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_DataClientToRouter,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_DataRouterToServer,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_DataServerToRouter,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_DataRouterToClient,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_Stats,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_ClientPingSampleRequest,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_ClientPingSampleReply,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_ClientToRouterSwitchedPrimary,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_RelayHealth,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_ConnectRequest,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_ConnectOK,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_ConnectionClosed,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_NoConnection,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_TicketDecryptRequest,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_TicketDecryptReply,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_P2PSessionRequest,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_P2PSessionEstablished,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_P2PStatsClient,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_P2PStatsRelay,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_P2PBadRoute,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_GameserverPingReply,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_LegacyGameserverRegistration,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_SetSecondaryAddressRequest,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_SetSecondaryAddressResult,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_RelayToRelayPingRequest,
        ESteamDatagramMsgID::k_ESteamDatagramMsg_RelayToRelayPingReply,
    ];
}

impl ::std::default::Default for ESteamDatagramMsgID {
    fn default() -> Self {
        ESteamDatagramMsgID::k_ESteamDatagramMsg_Invalid
    }
}



const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;

#[allow(unused_imports)]
use crate::steamnetworkingsockets_messages_certs::*;
#[allow(unused_imports)]
use crate::steamnetworkingsockets_messages::*;
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamNetworkingIPAddress {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramSignedMessageGeneric {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramRouterPingReply {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CMsgSteamDatagramGameserverPingRequestBody {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CMsgSteamDatagramGameserverPingRequestEnvelope {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramGameserverPingReplyData {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramNoSessionRelayToClient {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramNoSessionRelayToPeer {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgTOSTreatment {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramClientPingSampleRequest {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramClientPingSampleReply {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramClientSwitchedPrimary {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramConnectRequest {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramConnectOK {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamNetworkingP2PSDRRoutingSummary {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramP2PRoutingSummary {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramConnectionClosed {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramNoConnection {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CMsgSteamDatagramGameserverSessionRequest {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CMsgSteamDatagramGameserverSessionEstablished {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CMsgSteamDatagramConnectionStatsClientToRouter {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CMsgSteamDatagramConnectionStatsRouterToClient {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CMsgSteamDatagramConnectionStatsRouterToServer {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CMsgSteamDatagramConnectionStatsServerToRouter {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramP2PSessionRequestBody {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramP2PSessionRequest {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramP2PSessionEstablished {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CMsgSteamDatagramConnectionStatsP2PClientToRouter {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CMsgSteamDatagramConnectionStatsP2PRouterToClient {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CMsgSteamDatagramP2PBadRouteRouterToClient {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramP2PRoutes {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CMsgSteamDatagramSetSecondaryAddressRequest {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CMsgSteamDatagramSetSecondaryAddressResult {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
