// 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_auth.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:CMsgSteamDatagramRelayAuthTicket)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramRelayAuthTicket {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.time_expiry)
    pub time_expiry: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.authorized_client_identity_string)
    pub authorized_client_identity_string: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.gameserver_identity_string)
    pub gameserver_identity_string: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.authorized_public_ip)
    pub authorized_public_ip: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.gameserver_address)
    pub gameserver_address: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.app_id)
    pub app_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.virtual_port)
    pub virtual_port: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.extra_fields)
    pub extra_fields: ::std::vec::Vec<cmsg_steam_datagram_relay_auth_ticket::ExtraField>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.legacy_authorized_steam_id)
    pub legacy_authorized_steam_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.legacy_gameserver_steam_id)
    pub legacy_gameserver_steam_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.legacy_gameserver_pop_id)
    pub legacy_gameserver_pop_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.legacy_authorized_client_identity_binary)
    pub legacy_authorized_client_identity_binary: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.legacy_gameserver_identity_binary)
    pub legacy_gameserver_identity_binary: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramRelayAuthTicket.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed32 time_expiry = 1;

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

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

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

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

    // optional string authorized_client_identity_string = 14;

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

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

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

    // Param is passed by value, moved
    pub fn set_authorized_client_identity_string(&mut self, v: ::std::string::String) {
        self.authorized_client_identity_string = ::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_authorized_client_identity_string(&mut self) -> &mut ::std::string::String {
        if self.authorized_client_identity_string.is_none() {
            self.authorized_client_identity_string = ::std::option::Option::Some(::std::string::String::new());
        }
        self.authorized_client_identity_string.as_mut().unwrap()
    }

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

    // optional string gameserver_identity_string = 15;

    pub fn 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 fixed32 authorized_public_ip = 3;

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

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

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

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

    // optional bytes gameserver_address = 11;

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

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

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

    // Param is passed by value, moved
    pub fn set_gameserver_address(&mut self, v: ::std::vec::Vec<u8>) {
        self.gameserver_address = ::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_address(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.gameserver_address.is_none() {
            self.gameserver_address = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.gameserver_address.as_mut().unwrap()
    }

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

    // optional uint32 app_id = 7;

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

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

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

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

    // optional uint32 virtual_port = 10;

    pub fn 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 fixed64 legacy_authorized_steam_id = 2;

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

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

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

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

    // optional fixed64 legacy_gameserver_steam_id = 4;

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

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

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

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

    // optional fixed32 legacy_gameserver_pop_id = 9;

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

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

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

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

    // optional bytes legacy_authorized_client_identity_binary = 12;

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

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

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

    // Param is passed by value, moved
    pub fn set_legacy_authorized_client_identity_binary(&mut self, v: ::std::vec::Vec<u8>) {
        self.legacy_authorized_client_identity_binary = ::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_legacy_authorized_client_identity_binary(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.legacy_authorized_client_identity_binary.is_none() {
            self.legacy_authorized_client_identity_binary = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.legacy_authorized_client_identity_binary.as_mut().unwrap()
    }

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

    // optional bytes legacy_gameserver_identity_binary = 13;

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

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

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

    // Param is passed by value, moved
    pub fn set_legacy_gameserver_identity_binary(&mut self, v: ::std::vec::Vec<u8>) {
        self.legacy_gameserver_identity_binary = ::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_legacy_gameserver_identity_binary(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.legacy_gameserver_identity_binary.is_none() {
            self.legacy_gameserver_identity_binary = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.legacy_gameserver_identity_binary.as_mut().unwrap()
    }

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

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

    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.time_expiry = ::std::option::Option::Some(is.read_fixed32()?);
                },
                114 => {
                    self.authorized_client_identity_string = ::std::option::Option::Some(is.read_string()?);
                },
                122 => {
                    self.gameserver_identity_string = ::std::option::Option::Some(is.read_string()?);
                },
                29 => {
                    self.authorized_public_ip = ::std::option::Option::Some(is.read_fixed32()?);
                },
                90 => {
                    self.gameserver_address = ::std::option::Option::Some(is.read_bytes()?);
                },
                56 => {
                    self.app_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                80 => {
                    self.virtual_port = ::std::option::Option::Some(is.read_uint32()?);
                },
                66 => {
                    self.extra_fields.push(is.read_message()?);
                },
                17 => {
                    self.legacy_authorized_steam_id = ::std::option::Option::Some(is.read_fixed64()?);
                },
                33 => {
                    self.legacy_gameserver_steam_id = ::std::option::Option::Some(is.read_fixed64()?);
                },
                77 => {
                    self.legacy_gameserver_pop_id = ::std::option::Option::Some(is.read_fixed32()?);
                },
                98 => {
                    self.legacy_authorized_client_identity_binary = ::std::option::Option::Some(is.read_bytes()?);
                },
                106 => {
                    self.legacy_gameserver_identity_binary = ::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.time_expiry {
            my_size += 1 + 4;
        }
        if let Some(v) = self.authorized_client_identity_string.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(14, &v);
        }
        if let Some(v) = self.gameserver_identity_string.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(15, &v);
        }
        if let Some(v) = self.authorized_public_ip {
            my_size += 1 + 4;
        }
        if let Some(v) = self.gameserver_address.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(11, &v);
        }
        if let Some(v) = self.app_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.virtual_port {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(10, v);
        }
        for value in &self.extra_fields {
            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.legacy_authorized_steam_id {
            my_size += 1 + 8;
        }
        if let Some(v) = self.legacy_gameserver_steam_id {
            my_size += 1 + 8;
        }
        if let Some(v) = self.legacy_gameserver_pop_id {
            my_size += 1 + 4;
        }
        if let Some(v) = self.legacy_authorized_client_identity_binary.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(12, &v);
        }
        if let Some(v) = self.legacy_gameserver_identity_binary.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_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.time_expiry {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.authorized_client_identity_string.as_ref() {
            os.write_string(14, v)?;
        }
        if let Some(v) = self.gameserver_identity_string.as_ref() {
            os.write_string(15, v)?;
        }
        if let Some(v) = self.authorized_public_ip {
            os.write_fixed32(3, v)?;
        }
        if let Some(v) = self.gameserver_address.as_ref() {
            os.write_bytes(11, v)?;
        }
        if let Some(v) = self.app_id {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.virtual_port {
            os.write_uint32(10, v)?;
        }
        for v in &self.extra_fields {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
        };
        if let Some(v) = self.legacy_authorized_steam_id {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.legacy_gameserver_steam_id {
            os.write_fixed64(4, v)?;
        }
        if let Some(v) = self.legacy_gameserver_pop_id {
            os.write_fixed32(9, v)?;
        }
        if let Some(v) = self.legacy_authorized_client_identity_binary.as_ref() {
            os.write_bytes(12, v)?;
        }
        if let Some(v) = self.legacy_gameserver_identity_binary.as_ref() {
            os.write_bytes(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() -> CMsgSteamDatagramRelayAuthTicket {
        CMsgSteamDatagramRelayAuthTicket::new()
    }

    fn clear(&mut self) {
        self.time_expiry = ::std::option::Option::None;
        self.authorized_client_identity_string = ::std::option::Option::None;
        self.gameserver_identity_string = ::std::option::Option::None;
        self.authorized_public_ip = ::std::option::Option::None;
        self.gameserver_address = ::std::option::Option::None;
        self.app_id = ::std::option::Option::None;
        self.virtual_port = ::std::option::Option::None;
        self.extra_fields.clear();
        self.legacy_authorized_steam_id = ::std::option::Option::None;
        self.legacy_gameserver_steam_id = ::std::option::Option::None;
        self.legacy_gameserver_pop_id = ::std::option::Option::None;
        self.legacy_authorized_client_identity_binary = ::std::option::Option::None;
        self.legacy_gameserver_identity_binary = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramRelayAuthTicket {
        static instance: CMsgSteamDatagramRelayAuthTicket = CMsgSteamDatagramRelayAuthTicket {
            time_expiry: ::std::option::Option::None,
            authorized_client_identity_string: ::std::option::Option::None,
            gameserver_identity_string: ::std::option::Option::None,
            authorized_public_ip: ::std::option::Option::None,
            gameserver_address: ::std::option::Option::None,
            app_id: ::std::option::Option::None,
            virtual_port: ::std::option::Option::None,
            extra_fields: ::std::vec::Vec::new(),
            legacy_authorized_steam_id: ::std::option::Option::None,
            legacy_gameserver_steam_id: ::std::option::Option::None,
            legacy_gameserver_pop_id: ::std::option::Option::None,
            legacy_authorized_client_identity_binary: ::std::option::Option::None,
            legacy_gameserver_identity_binary: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CMsgSteamDatagramRelayAuthTicket`
pub mod cmsg_steam_datagram_relay_auth_ticket {
    // @@protoc_insertion_point(message:CMsgSteamDatagramRelayAuthTicket.ExtraField)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct ExtraField {
        // message fields
        // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.ExtraField.name)
        pub name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.ExtraField.string_value)
        pub string_value: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.ExtraField.int64_value)
        pub int64_value: ::std::option::Option<i64>,
        // @@protoc_insertion_point(field:CMsgSteamDatagramRelayAuthTicket.ExtraField.fixed64_value)
        pub fixed64_value: ::std::option::Option<u64>,
        // special fields
        // @@protoc_insertion_point(special_field:CMsgSteamDatagramRelayAuthTicket.ExtraField.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional string name = 1;

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

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

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

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

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

        // optional string string_value = 2;

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

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

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

        // Param is passed by value, moved
        pub fn set_string_value(&mut self, v: ::std::string::String) {
            self.string_value = ::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_string_value(&mut self) -> &mut ::std::string::String {
            if self.string_value.is_none() {
                self.string_value = ::std::option::Option::Some(::std::string::String::new());
            }
            self.string_value.as_mut().unwrap()
        }

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

        // optional sint64 int64_value = 3;

        pub fn int64_value(&self) -> i64 {
            self.int64_value.unwrap_or(0)
        }

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

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

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

        // optional fixed64 fixed64_value = 5;

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

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

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

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

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

        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.name = ::std::option::Option::Some(is.read_string()?);
                    },
                    18 => {
                        self.string_value = ::std::option::Option::Some(is.read_string()?);
                    },
                    24 => {
                        self.int64_value = ::std::option::Option::Some(is.read_sint64()?);
                    },
                    41 => {
                        self.fixed64_value = ::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.name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
            }
            if let Some(v) = self.string_value.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
            }
            if let Some(v) = self.int64_value {
                my_size += ::steam_vent_proto_common::protobuf::rt::sint64_size(3, v);
            }
            if let Some(v) = self.fixed64_value {
                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.name.as_ref() {
                os.write_string(1, v)?;
            }
            if let Some(v) = self.string_value.as_ref() {
                os.write_string(2, v)?;
            }
            if let Some(v) = self.int64_value {
                os.write_sint64(3, v)?;
            }
            if let Some(v) = self.fixed64_value {
                os.write_fixed64(5, v)?;
            }
            os.write_unknown_fields(self.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() -> ExtraField {
            ExtraField::new()
        }

        fn clear(&mut self) {
            self.name = ::std::option::Option::None;
            self.string_value = ::std::option::Option::None;
            self.int64_value = ::std::option::Option::None;
            self.fixed64_value = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static ExtraField {
            static instance: ExtraField = ExtraField {
                name: ::std::option::Option::None,
                string_value: ::std::option::Option::None,
                int64_value: ::std::option::Option::None,
                fixed64_value: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramSignedRelayAuthTicket)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramSignedRelayAuthTicket {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramSignedRelayAuthTicket.reserved_do_not_use)
    pub reserved_do_not_use: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramSignedRelayAuthTicket.ticket)
    pub ticket: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramSignedRelayAuthTicket.signature)
    pub signature: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramSignedRelayAuthTicket.key_id)
    pub key_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramSignedRelayAuthTicket.certs)
    pub certs: ::std::vec::Vec<super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramSignedRelayAuthTicket.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed64 reserved_do_not_use = 1;

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

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

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

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

    // optional bytes ticket = 3;

    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 bytes signature = 4;

    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 fixed64 key_id = 2;

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                9 => {
                    self.reserved_do_not_use = ::std::option::Option::Some(is.read_fixed64()?);
                },
                26 => {
                    self.ticket = ::std::option::Option::Some(is.read_bytes()?);
                },
                34 => {
                    self.signature = ::std::option::Option::Some(is.read_bytes()?);
                },
                17 => {
                    self.key_id = ::std::option::Option::Some(is.read_fixed64()?);
                },
                42 => {
                    self.certs.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.reserved_do_not_use {
            my_size += 1 + 8;
        }
        if let Some(v) = self.ticket.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(3, &v);
        }
        if let Some(v) = self.signature.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(4, &v);
        }
        if let Some(v) = self.key_id {
            my_size += 1 + 8;
        }
        for value in &self.certs {
            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.reserved_do_not_use {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.ticket.as_ref() {
            os.write_bytes(3, v)?;
        }
        if let Some(v) = self.signature.as_ref() {
            os.write_bytes(4, v)?;
        }
        if let Some(v) = self.key_id {
            os.write_fixed64(2, v)?;
        }
        for v in &self.certs {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, 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() -> CMsgSteamDatagramSignedRelayAuthTicket {
        CMsgSteamDatagramSignedRelayAuthTicket::new()
    }

    fn clear(&mut self) {
        self.reserved_do_not_use = ::std::option::Option::None;
        self.ticket = ::std::option::Option::None;
        self.signature = ::std::option::Option::None;
        self.key_id = ::std::option::Option::None;
        self.certs.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramSignedRelayAuthTicket {
        static instance: CMsgSteamDatagramSignedRelayAuthTicket = CMsgSteamDatagramSignedRelayAuthTicket {
            reserved_do_not_use: ::std::option::Option::None,
            ticket: ::std::option::Option::None,
            signature: ::std::option::Option::None,
            key_id: ::std::option::Option::None,
            certs: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional bytes private_key = 1;

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

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

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

    // Param is passed by value, moved
    pub fn set_private_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.private_key = ::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_private_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.private_key.is_none() {
            self.private_key = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.private_key.as_mut().unwrap()
    }

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

    // optional bytes cert = 2;

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

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

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

    // Param is passed by value, moved
    pub fn set_cert(&mut self, v: ::std::vec::Vec<u8>) {
        self.cert = ::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_cert(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.cert.is_none() {
            self.cert = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.cert.as_mut().unwrap()
    }

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

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

    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.private_key = ::std::option::Option::Some(is.read_bytes()?);
                },
                18 => {
                    self.cert = ::std::option::Option::Some(is.read_bytes()?);
                },
                26 => {
                    self.relay_tickets.push(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.private_key.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(v) = self.cert.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(2, &v);
        }
        for value in &self.relay_tickets {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(3, &value);
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

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

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

    fn default_instance() -> &'static CMsgSteamDatagramCachedCredentialsForApp {
        static instance: CMsgSteamDatagramCachedCredentialsForApp = CMsgSteamDatagramCachedCredentialsForApp {
            private_key: ::std::option::Option::None,
            cert: ::std::option::Option::None,
            relay_tickets: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgSteamDatagramGameCoordinatorServerLogin)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramGameCoordinatorServerLogin {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameCoordinatorServerLogin.time_generated)
    pub time_generated: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameCoordinatorServerLogin.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameCoordinatorServerLogin.routing)
    pub routing: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameCoordinatorServerLogin.appdata)
    pub appdata: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameCoordinatorServerLogin.legacy_identity_binary)
    pub legacy_identity_binary: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameCoordinatorServerLogin.identity_string)
    pub identity_string: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramGameCoordinatorServerLogin.dummy_steam_id)
    pub dummy_steam_id: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramGameCoordinatorServerLogin.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 time_generated = 1;

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

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

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

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

    // optional uint32 appid = 2;

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

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

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

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

    // optional bytes routing = 3;

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

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

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

    // Param is passed by value, moved
    pub fn set_routing(&mut self, v: ::std::vec::Vec<u8>) {
        self.routing = ::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(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.routing.is_none() {
            self.routing = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.routing.as_mut().unwrap()
    }

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

    // optional bytes appdata = 4;

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

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

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

    // Param is passed by value, moved
    pub fn set_appdata(&mut self, v: ::std::vec::Vec<u8>) {
        self.appdata = ::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_appdata(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.appdata.is_none() {
            self.appdata = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.appdata.as_mut().unwrap()
    }

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

    // optional bytes legacy_identity_binary = 5;

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

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

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

    // Param is passed by value, moved
    pub fn set_legacy_identity_binary(&mut self, v: ::std::vec::Vec<u8>) {
        self.legacy_identity_binary = ::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_legacy_identity_binary(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.legacy_identity_binary.is_none() {
            self.legacy_identity_binary = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.legacy_identity_binary.as_mut().unwrap()
    }

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

    // optional string identity_string = 6;

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

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

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

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

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

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

    // optional fixed64 dummy_steam_id = 99;

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.time_generated = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                26 => {
                    self.routing = ::std::option::Option::Some(is.read_bytes()?);
                },
                34 => {
                    self.appdata = ::std::option::Option::Some(is.read_bytes()?);
                },
                42 => {
                    self.legacy_identity_binary = ::std::option::Option::Some(is.read_bytes()?);
                },
                50 => {
                    self.identity_string = ::std::option::Option::Some(is.read_string()?);
                },
                793 => {
                    self.dummy_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.time_generated {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.routing.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(3, &v);
        }
        if let Some(v) = self.appdata.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(4, &v);
        }
        if let Some(v) = self.legacy_identity_binary.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(5, &v);
        }
        if let Some(v) = self.identity_string.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.dummy_steam_id {
            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.time_generated {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.routing.as_ref() {
            os.write_bytes(3, v)?;
        }
        if let Some(v) = self.appdata.as_ref() {
            os.write_bytes(4, v)?;
        }
        if let Some(v) = self.legacy_identity_binary.as_ref() {
            os.write_bytes(5, v)?;
        }
        if let Some(v) = self.identity_string.as_ref() {
            os.write_string(6, v)?;
        }
        if let Some(v) = self.dummy_steam_id {
            os.write_fixed64(99, v)?;
        }
        os.write_unknown_fields(self.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() -> CMsgSteamDatagramGameCoordinatorServerLogin {
        CMsgSteamDatagramGameCoordinatorServerLogin::new()
    }

    fn clear(&mut self) {
        self.time_generated = ::std::option::Option::None;
        self.appid = ::std::option::Option::None;
        self.routing = ::std::option::Option::None;
        self.appdata = ::std::option::Option::None;
        self.legacy_identity_binary = ::std::option::Option::None;
        self.identity_string = ::std::option::Option::None;
        self.dummy_steam_id = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramGameCoordinatorServerLogin {
        static instance: CMsgSteamDatagramGameCoordinatorServerLogin = CMsgSteamDatagramGameCoordinatorServerLogin {
            time_generated: ::std::option::Option::None,
            appid: ::std::option::Option::None,
            routing: ::std::option::Option::None,
            appdata: ::std::option::Option::None,
            legacy_identity_binary: ::std::option::Option::None,
            identity_string: ::std::option::Option::None,
            dummy_steam_id: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional bytes login = 2;

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

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

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

    // Param is passed by value, moved
    pub fn set_login(&mut self, v: ::std::vec::Vec<u8>) {
        self.login = ::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_login(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.login.is_none() {
            self.login = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.login.as_mut().unwrap()
    }

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

    // optional bytes signature = 3;

    pub fn 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 CMsgSteamDatagramSignedGameCoordinatorServerLogin {
    const NAME: &'static str = "CMsgSteamDatagramSignedGameCoordinatorServerLogin";

    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.login = ::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.login.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.login.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() -> CMsgSteamDatagramSignedGameCoordinatorServerLogin {
        CMsgSteamDatagramSignedGameCoordinatorServerLogin::new()
    }

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

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

// @@protoc_insertion_point(message:CMsgSteamDatagramHostedServerAddressPlaintext)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgSteamDatagramHostedServerAddressPlaintext {
    // message fields
    // @@protoc_insertion_point(field:CMsgSteamDatagramHostedServerAddressPlaintext.ipv4)
    pub ipv4: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramHostedServerAddressPlaintext.ipv6)
    pub ipv6: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramHostedServerAddressPlaintext.port)
    pub port: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramHostedServerAddressPlaintext.routing_secret)
    pub routing_secret: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgSteamDatagramHostedServerAddressPlaintext.protocol_version)
    pub protocol_version: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgSteamDatagramHostedServerAddressPlaintext.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl CMsgSteamDatagramHostedServerAddressPlaintext {
    pub fn new() -> CMsgSteamDatagramHostedServerAddressPlaintext {
        ::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 bytes ipv6 = 2;

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

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

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

    // Param is passed by value, moved
    pub fn set_ipv6(&mut self, v: ::std::vec::Vec<u8>) {
        self.ipv6 = ::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_ipv6(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.ipv6.is_none() {
            self.ipv6 = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.ipv6.as_mut().unwrap()
    }

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

    // optional uint32 port = 3;

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

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

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

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

    // optional fixed64 routing_secret = 4;

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

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

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

    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()?);
                },
                18 => {
                    self.ipv6 = ::std::option::Option::Some(is.read_bytes()?);
                },
                24 => {
                    self.port = ::std::option::Option::Some(is.read_uint32()?);
                },
                33 => {
                    self.routing_secret = ::std::option::Option::Some(is.read_fixed64()?);
                },
                40 => {
                    self.protocol_version = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.ipv4 {
            my_size += 1 + 4;
        }
        if let Some(v) = self.ipv6.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(v) = self.port {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.routing_secret {
            my_size += 1 + 8;
        }
        if let Some(v) = self.protocol_version {
            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.ipv4 {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.ipv6.as_ref() {
            os.write_bytes(2, v)?;
        }
        if let Some(v) = self.port {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.routing_secret {
            os.write_fixed64(4, v)?;
        }
        if let Some(v) = self.protocol_version {
            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() -> CMsgSteamDatagramHostedServerAddressPlaintext {
        CMsgSteamDatagramHostedServerAddressPlaintext::new()
    }

    fn clear(&mut self) {
        self.ipv4 = ::std::option::Option::None;
        self.ipv6 = ::std::option::Option::None;
        self.port = ::std::option::Option::None;
        self.routing_secret = ::std::option::Option::None;
        self.protocol_version = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgSteamDatagramHostedServerAddressPlaintext {
        static instance: CMsgSteamDatagramHostedServerAddressPlaintext = CMsgSteamDatagramHostedServerAddressPlaintext {
            ipv4: ::std::option::Option::None,
            ipv6: ::std::option::Option::None,
            port: ::std::option::Option::None,
            routing_secret: ::std::option::Option::None,
            protocol_version: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}


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

#[allow(unused_imports)]
use crate::steamnetworkingsockets_messages_certs::*;
impl ::steam_vent_proto_common::RpcMessage for CMsgSteamDatagramRelayAuthTicket {
    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 CMsgSteamDatagramSignedRelayAuthTicket {
    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 CMsgSteamDatagramCachedCredentialsForApp {
    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 CMsgSteamDatagramGameCoordinatorServerLogin {
    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 CMsgSteamDatagramSignedGameCoordinatorServerLogin {
    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 CMsgSteamDatagramHostedServerAddressPlaintext {
    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
    }
}
