initial import from steam-vent repo

src/generated/connectionless_netmessages.rs

@@ -0,0 +1,582 @@
+// 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 `connectionless_netmessages.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:C2S_CONNECT_Message)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct C2S_CONNECT_Message {
+    // message fields
+    // @@protoc_insertion_point(field:C2S_CONNECT_Message.host_version)
+    pub host_version: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:C2S_CONNECT_Message.auth_protocol)
+    pub auth_protocol: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:C2S_CONNECT_Message.challenge_number)
+    pub challenge_number: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:C2S_CONNECT_Message.reservation_cookie)
+    pub reservation_cookie: ::std::option::Option<u64>,
+    // @@protoc_insertion_point(field:C2S_CONNECT_Message.low_violence)
+    pub low_violence: ::std::option::Option<bool>,
+    // @@protoc_insertion_point(field:C2S_CONNECT_Message.encrypted_password)
+    pub encrypted_password: ::std::option::Option<::std::vec::Vec<u8>>,
+    // @@protoc_insertion_point(field:C2S_CONNECT_Message.splitplayers)
+    pub splitplayers: ::std::vec::Vec<super::netmessages::CCLCMsg_SplitPlayerConnect>,
+    // @@protoc_insertion_point(field:C2S_CONNECT_Message.auth_steam)
+    pub auth_steam: ::std::option::Option<::std::vec::Vec<u8>>,
+    // @@protoc_insertion_point(field:C2S_CONNECT_Message.challenge_context)
+    pub challenge_context: ::std::option::Option<::std::string::String>,
+    // special fields
+    // @@protoc_insertion_point(special_field:C2S_CONNECT_Message.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a C2S_CONNECT_Message {
+    fn default() -> &'a C2S_CONNECT_Message {
+        <C2S_CONNECT_Message as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl C2S_CONNECT_Message {
+    pub fn new() -> C2S_CONNECT_Message {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 host_version = 1;
+
+    pub fn host_version(&self) -> u32 {
+        self.host_version.unwrap_or(0)
+    }
+
+    pub fn clear_host_version(&mut self) {
+        self.host_version = ::std::option::Option::None;
+    }
+
+    pub fn has_host_version(&self) -> bool {
+        self.host_version.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_host_version(&mut self, v: u32) {
+        self.host_version = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 auth_protocol = 2;
+
+    pub fn auth_protocol(&self) -> u32 {
+        self.auth_protocol.unwrap_or(0)
+    }
+
+    pub fn clear_auth_protocol(&mut self) {
+        self.auth_protocol = ::std::option::Option::None;
+    }
+
+    pub fn has_auth_protocol(&self) -> bool {
+        self.auth_protocol.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_auth_protocol(&mut self, v: u32) {
+        self.auth_protocol = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 challenge_number = 3;
+
+    pub fn challenge_number(&self) -> u32 {
+        self.challenge_number.unwrap_or(0)
+    }
+
+    pub fn clear_challenge_number(&mut self) {
+        self.challenge_number = ::std::option::Option::None;
+    }
+
+    pub fn has_challenge_number(&self) -> bool {
+        self.challenge_number.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_challenge_number(&mut self, v: u32) {
+        self.challenge_number = ::std::option::Option::Some(v);
+    }
+
+    // optional fixed64 reservation_cookie = 4;
+
+    pub fn reservation_cookie(&self) -> u64 {
+        self.reservation_cookie.unwrap_or(0)
+    }
+
+    pub fn clear_reservation_cookie(&mut self) {
+        self.reservation_cookie = ::std::option::Option::None;
+    }
+
+    pub fn has_reservation_cookie(&self) -> bool {
+        self.reservation_cookie.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_reservation_cookie(&mut self, v: u64) {
+        self.reservation_cookie = ::std::option::Option::Some(v);
+    }
+
+    // optional bool low_violence = 5;
+
+    pub fn low_violence(&self) -> bool {
+        self.low_violence.unwrap_or(false)
+    }
+
+    pub fn clear_low_violence(&mut self) {
+        self.low_violence = ::std::option::Option::None;
+    }
+
+    pub fn has_low_violence(&self) -> bool {
+        self.low_violence.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_low_violence(&mut self, v: bool) {
+        self.low_violence = ::std::option::Option::Some(v);
+    }
+
+    // optional bytes encrypted_password = 6;
+
+    pub fn encrypted_password(&self) -> &[u8] {
+        match self.encrypted_password.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_encrypted_password(&mut self) {
+        self.encrypted_password = ::std::option::Option::None;
+    }
+
+    pub fn has_encrypted_password(&self) -> bool {
+        self.encrypted_password.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_encrypted_password(&mut self, v: ::std::vec::Vec<u8>) {
+        self.encrypted_password = ::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_password(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.encrypted_password.is_none() {
+            self.encrypted_password = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.encrypted_password.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_encrypted_password(&mut self) -> ::std::vec::Vec<u8> {
+        self.encrypted_password.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    // optional bytes auth_steam = 8;
+
+    pub fn auth_steam(&self) -> &[u8] {
+        match self.auth_steam.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_auth_steam(&mut self) {
+        self.auth_steam = ::std::option::Option::None;
+    }
+
+    pub fn has_auth_steam(&self) -> bool {
+        self.auth_steam.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_auth_steam(&mut self, v: ::std::vec::Vec<u8>) {
+        self.auth_steam = ::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_auth_steam(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.auth_steam.is_none() {
+            self.auth_steam = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.auth_steam.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_auth_steam(&mut self) -> ::std::vec::Vec<u8> {
+        self.auth_steam.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    // optional string challenge_context = 9;
+
+    pub fn challenge_context(&self) -> &str {
+        match self.challenge_context.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_challenge_context(&mut self) {
+        self.challenge_context = ::std::option::Option::None;
+    }
+
+    pub fn has_challenge_context(&self) -> bool {
+        self.challenge_context.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_challenge_context(&mut self, v: ::std::string::String) {
+        self.challenge_context = ::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_challenge_context(&mut self) -> &mut ::std::string::String {
+        if self.challenge_context.is_none() {
+            self.challenge_context = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.challenge_context.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_challenge_context(&mut self) -> ::std::string::String {
+        self.challenge_context.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for C2S_CONNECT_Message {
+    const NAME: &'static str = "C2S_CONNECT_Message";
+
+    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.host_version = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                16 => {
+                    self.auth_protocol = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                24 => {
+                    self.challenge_number = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                33 => {
+                    self.reservation_cookie = ::std::option::Option::Some(is.read_fixed64()?);
+                },
+                40 => {
+                    self.low_violence = ::std::option::Option::Some(is.read_bool()?);
+                },
+                50 => {
+                    self.encrypted_password = ::std::option::Option::Some(is.read_bytes()?);
+                },
+                58 => {
+                    self.splitplayers.push(is.read_message()?);
+                },
+                66 => {
+                    self.auth_steam = ::std::option::Option::Some(is.read_bytes()?);
+                },
+                74 => {
+                    self.challenge_context = ::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.host_version {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.auth_protocol {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
+        }
+        if let Some(v) = self.challenge_number {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
+        }
+        if let Some(v) = self.reservation_cookie {
+            my_size += 1 + 8;
+        }
+        if let Some(v) = self.low_violence {
+            my_size += 1 + 1;
+        }
+        if let Some(v) = self.encrypted_password.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(6, &v);
+        }
+        for value in &self.splitplayers {
+            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.auth_steam.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(8, &v);
+        }
+        if let Some(v) = self.challenge_context.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::string_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.host_version {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.auth_protocol {
+            os.write_uint32(2, v)?;
+        }
+        if let Some(v) = self.challenge_number {
+            os.write_uint32(3, v)?;
+        }
+        if let Some(v) = self.reservation_cookie {
+            os.write_fixed64(4, v)?;
+        }
+        if let Some(v) = self.low_violence {
+            os.write_bool(5, v)?;
+        }
+        if let Some(v) = self.encrypted_password.as_ref() {
+            os.write_bytes(6, v)?;
+        }
+        for v in &self.splitplayers {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
+        };
+        if let Some(v) = self.auth_steam.as_ref() {
+            os.write_bytes(8, v)?;
+        }
+        if let Some(v) = self.challenge_context.as_ref() {
+            os.write_string(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() -> C2S_CONNECT_Message {
+        C2S_CONNECT_Message::new()
+    }
+
+    fn clear(&mut self) {
+        self.host_version = ::std::option::Option::None;
+        self.auth_protocol = ::std::option::Option::None;
+        self.challenge_number = ::std::option::Option::None;
+        self.reservation_cookie = ::std::option::Option::None;
+        self.low_violence = ::std::option::Option::None;
+        self.encrypted_password = ::std::option::Option::None;
+        self.splitplayers.clear();
+        self.auth_steam = ::std::option::Option::None;
+        self.challenge_context = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static C2S_CONNECT_Message {
+        static instance: C2S_CONNECT_Message = C2S_CONNECT_Message {
+            host_version: ::std::option::Option::None,
+            auth_protocol: ::std::option::Option::None,
+            challenge_number: ::std::option::Option::None,
+            reservation_cookie: ::std::option::Option::None,
+            low_violence: ::std::option::Option::None,
+            encrypted_password: ::std::option::Option::None,
+            splitplayers: ::std::vec::Vec::new(),
+            auth_steam: ::std::option::Option::None,
+            challenge_context: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:C2S_CONNECTION_Message)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct C2S_CONNECTION_Message {
+    // message fields
+    // @@protoc_insertion_point(field:C2S_CONNECTION_Message.addon_name)
+    pub addon_name: ::std::option::Option<::std::string::String>,
+    // special fields
+    // @@protoc_insertion_point(special_field:C2S_CONNECTION_Message.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a C2S_CONNECTION_Message {
+    fn default() -> &'a C2S_CONNECTION_Message {
+        <C2S_CONNECTION_Message as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl C2S_CONNECTION_Message {
+    pub fn new() -> C2S_CONNECTION_Message {
+        ::std::default::Default::default()
+    }
+
+    // optional string addon_name = 1;
+
+    pub fn addon_name(&self) -> &str {
+        match self.addon_name.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_addon_name(&mut self) {
+        self.addon_name = ::std::option::Option::None;
+    }
+
+    pub fn has_addon_name(&self) -> bool {
+        self.addon_name.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_addon_name(&mut self, v: ::std::string::String) {
+        self.addon_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_addon_name(&mut self) -> &mut ::std::string::String {
+        if self.addon_name.is_none() {
+            self.addon_name = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.addon_name.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_addon_name(&mut self) -> ::std::string::String {
+        self.addon_name.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for C2S_CONNECTION_Message {
+    const NAME: &'static str = "C2S_CONNECTION_Message";
+
+    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.addon_name = ::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.addon_name.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.addon_name.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() -> C2S_CONNECTION_Message {
+        C2S_CONNECTION_Message::new()
+    }
+
+    fn clear(&mut self) {
+        self.addon_name = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static C2S_CONNECTION_Message {
+        static instance: C2S_CONNECTION_Message = C2S_CONNECTION_Message {
+            addon_name: ::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::netmessages::*;
+impl ::steam_vent_proto_common::RpcMessage for C2S_CONNECT_Message {
+    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 C2S_CONNECTION_Message {
+    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
+    }
+}

src/generated/cs_gameevents.rs

@@ -0,0 +1,907 @@
+// 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 `cs_gameevents.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:CMsgTEPlayerAnimEvent)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CMsgTEPlayerAnimEvent {
+    // message fields
+    // @@protoc_insertion_point(field:CMsgTEPlayerAnimEvent.player)
+    pub player: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CMsgTEPlayerAnimEvent.event)
+    pub event: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CMsgTEPlayerAnimEvent.data)
+    pub data: ::std::option::Option<i32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CMsgTEPlayerAnimEvent.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CMsgTEPlayerAnimEvent {
+    fn default() -> &'a CMsgTEPlayerAnimEvent {
+        <CMsgTEPlayerAnimEvent as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CMsgTEPlayerAnimEvent {
+    pub fn new() -> CMsgTEPlayerAnimEvent {
+        ::std::default::Default::default()
+    }
+
+    // optional fixed32 player = 1;
+
+    pub fn player(&self) -> u32 {
+        self.player.unwrap_or(16777215u32)
+    }
+
+    pub fn clear_player(&mut self) {
+        self.player = ::std::option::Option::None;
+    }
+
+    pub fn has_player(&self) -> bool {
+        self.player.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_player(&mut self, v: u32) {
+        self.player = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 event = 2;
+
+    pub fn event(&self) -> u32 {
+        self.event.unwrap_or(0)
+    }
+
+    pub fn clear_event(&mut self) {
+        self.event = ::std::option::Option::None;
+    }
+
+    pub fn has_event(&self) -> bool {
+        self.event.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_event(&mut self, v: u32) {
+        self.event = ::std::option::Option::Some(v);
+    }
+
+    // optional int32 data = 3;
+
+    pub fn data(&self) -> i32 {
+        self.data.unwrap_or(0)
+    }
+
+    pub fn clear_data(&mut self) {
+        self.data = ::std::option::Option::None;
+    }
+
+    pub fn has_data(&self) -> bool {
+        self.data.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_data(&mut self, v: i32) {
+        self.data = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CMsgTEPlayerAnimEvent {
+    const NAME: &'static str = "CMsgTEPlayerAnimEvent";
+
+    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.player = ::std::option::Option::Some(is.read_fixed32()?);
+                },
+                16 => {
+                    self.event = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                24 => {
+                    self.data = ::std::option::Option::Some(is.read_int32()?);
+                },
+                tag => {
+                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u64 {
+        let mut my_size = 0;
+        if let Some(v) = self.player {
+            my_size += 1 + 4;
+        }
+        if let Some(v) = self.event {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
+        }
+        if let Some(v) = self.data {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_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.player {
+            os.write_fixed32(1, v)?;
+        }
+        if let Some(v) = self.event {
+            os.write_uint32(2, v)?;
+        }
+        if let Some(v) = self.data {
+            os.write_int32(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() -> CMsgTEPlayerAnimEvent {
+        CMsgTEPlayerAnimEvent::new()
+    }
+
+    fn clear(&mut self) {
+        self.player = ::std::option::Option::None;
+        self.event = ::std::option::Option::None;
+        self.data = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CMsgTEPlayerAnimEvent {
+        static instance: CMsgTEPlayerAnimEvent = CMsgTEPlayerAnimEvent {
+            player: ::std::option::Option::None,
+            event: ::std::option::Option::None,
+            data: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CMsgTERadioIcon)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CMsgTERadioIcon {
+    // message fields
+    // @@protoc_insertion_point(field:CMsgTERadioIcon.player)
+    pub player: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CMsgTERadioIcon.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CMsgTERadioIcon {
+    fn default() -> &'a CMsgTERadioIcon {
+        <CMsgTERadioIcon as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CMsgTERadioIcon {
+    pub fn new() -> CMsgTERadioIcon {
+        ::std::default::Default::default()
+    }
+
+    // optional fixed32 player = 1;
+
+    pub fn player(&self) -> u32 {
+        self.player.unwrap_or(16777215u32)
+    }
+
+    pub fn clear_player(&mut self) {
+        self.player = ::std::option::Option::None;
+    }
+
+    pub fn has_player(&self) -> bool {
+        self.player.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_player(&mut self, v: u32) {
+        self.player = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CMsgTERadioIcon {
+    const NAME: &'static str = "CMsgTERadioIcon";
+
+    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.player = ::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.player {
+            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.player {
+            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() -> CMsgTERadioIcon {
+        CMsgTERadioIcon::new()
+    }
+
+    fn clear(&mut self) {
+        self.player = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CMsgTERadioIcon {
+        static instance: CMsgTERadioIcon = CMsgTERadioIcon {
+            player: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CMsgTEFireBullets)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CMsgTEFireBullets {
+    // message fields
+    // @@protoc_insertion_point(field:CMsgTEFireBullets.origin)
+    pub origin: ::steam_vent_proto_common::protobuf::MessageField<super::networkbasetypes::CMsgVector>,
+    // @@protoc_insertion_point(field:CMsgTEFireBullets.angles)
+    pub angles: ::steam_vent_proto_common::protobuf::MessageField<super::networkbasetypes::CMsgQAngle>,
+    // @@protoc_insertion_point(field:CMsgTEFireBullets.weapon_id)
+    pub weapon_id: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CMsgTEFireBullets.mode)
+    pub mode: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CMsgTEFireBullets.seed)
+    pub seed: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CMsgTEFireBullets.player)
+    pub player: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CMsgTEFireBullets.inaccuracy)
+    pub inaccuracy: ::std::option::Option<f32>,
+    // @@protoc_insertion_point(field:CMsgTEFireBullets.recoil_index)
+    pub recoil_index: ::std::option::Option<f32>,
+    // @@protoc_insertion_point(field:CMsgTEFireBullets.spread)
+    pub spread: ::std::option::Option<f32>,
+    // @@protoc_insertion_point(field:CMsgTEFireBullets.sound_type)
+    pub sound_type: ::std::option::Option<i32>,
+    // @@protoc_insertion_point(field:CMsgTEFireBullets.item_def_index)
+    pub item_def_index: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CMsgTEFireBullets.sound_dsp_effect)
+    pub sound_dsp_effect: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CMsgTEFireBullets.ent_origin)
+    pub ent_origin: ::steam_vent_proto_common::protobuf::MessageField<super::networkbasetypes::CMsgVector>,
+    // @@protoc_insertion_point(field:CMsgTEFireBullets.num_bullets_remaining)
+    pub num_bullets_remaining: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CMsgTEFireBullets.attack_type)
+    pub attack_type: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CMsgTEFireBullets.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CMsgTEFireBullets {
+    fn default() -> &'a CMsgTEFireBullets {
+        <CMsgTEFireBullets as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CMsgTEFireBullets {
+    pub fn new() -> CMsgTEFireBullets {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 weapon_id = 3;
+
+    pub fn weapon_id(&self) -> u32 {
+        self.weapon_id.unwrap_or(16777215u32)
+    }
+
+    pub fn clear_weapon_id(&mut self) {
+        self.weapon_id = ::std::option::Option::None;
+    }
+
+    pub fn has_weapon_id(&self) -> bool {
+        self.weapon_id.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_weapon_id(&mut self, v: u32) {
+        self.weapon_id = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 mode = 4;
+
+    pub fn mode(&self) -> u32 {
+        self.mode.unwrap_or(0)
+    }
+
+    pub fn clear_mode(&mut self) {
+        self.mode = ::std::option::Option::None;
+    }
+
+    pub fn has_mode(&self) -> bool {
+        self.mode.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_mode(&mut self, v: u32) {
+        self.mode = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 seed = 5;
+
+    pub fn seed(&self) -> u32 {
+        self.seed.unwrap_or(0)
+    }
+
+    pub fn clear_seed(&mut self) {
+        self.seed = ::std::option::Option::None;
+    }
+
+    pub fn has_seed(&self) -> bool {
+        self.seed.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_seed(&mut self, v: u32) {
+        self.seed = ::std::option::Option::Some(v);
+    }
+
+    // optional fixed32 player = 6;
+
+    pub fn player(&self) -> u32 {
+        self.player.unwrap_or(16777215u32)
+    }
+
+    pub fn clear_player(&mut self) {
+        self.player = ::std::option::Option::None;
+    }
+
+    pub fn has_player(&self) -> bool {
+        self.player.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_player(&mut self, v: u32) {
+        self.player = ::std::option::Option::Some(v);
+    }
+
+    // optional float inaccuracy = 7;
+
+    pub fn inaccuracy(&self) -> f32 {
+        self.inaccuracy.unwrap_or(0.)
+    }
+
+    pub fn clear_inaccuracy(&mut self) {
+        self.inaccuracy = ::std::option::Option::None;
+    }
+
+    pub fn has_inaccuracy(&self) -> bool {
+        self.inaccuracy.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_inaccuracy(&mut self, v: f32) {
+        self.inaccuracy = ::std::option::Option::Some(v);
+    }
+
+    // optional float recoil_index = 8;
+
+    pub fn recoil_index(&self) -> f32 {
+        self.recoil_index.unwrap_or(0.)
+    }
+
+    pub fn clear_recoil_index(&mut self) {
+        self.recoil_index = ::std::option::Option::None;
+    }
+
+    pub fn has_recoil_index(&self) -> bool {
+        self.recoil_index.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_recoil_index(&mut self, v: f32) {
+        self.recoil_index = ::std::option::Option::Some(v);
+    }
+
+    // optional float spread = 9;
+
+    pub fn spread(&self) -> f32 {
+        self.spread.unwrap_or(0.)
+    }
+
+    pub fn clear_spread(&mut self) {
+        self.spread = ::std::option::Option::None;
+    }
+
+    pub fn has_spread(&self) -> bool {
+        self.spread.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_spread(&mut self, v: f32) {
+        self.spread = ::std::option::Option::Some(v);
+    }
+
+    // optional int32 sound_type = 10;
+
+    pub fn sound_type(&self) -> i32 {
+        self.sound_type.unwrap_or(0)
+    }
+
+    pub fn clear_sound_type(&mut self) {
+        self.sound_type = ::std::option::Option::None;
+    }
+
+    pub fn has_sound_type(&self) -> bool {
+        self.sound_type.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_sound_type(&mut self, v: i32) {
+        self.sound_type = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 item_def_index = 11;
+
+    pub fn item_def_index(&self) -> u32 {
+        self.item_def_index.unwrap_or(0)
+    }
+
+    pub fn clear_item_def_index(&mut self) {
+        self.item_def_index = ::std::option::Option::None;
+    }
+
+    pub fn has_item_def_index(&self) -> bool {
+        self.item_def_index.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_item_def_index(&mut self, v: u32) {
+        self.item_def_index = ::std::option::Option::Some(v);
+    }
+
+    // optional fixed32 sound_dsp_effect = 12;
+
+    pub fn sound_dsp_effect(&self) -> u32 {
+        self.sound_dsp_effect.unwrap_or(0)
+    }
+
+    pub fn clear_sound_dsp_effect(&mut self) {
+        self.sound_dsp_effect = ::std::option::Option::None;
+    }
+
+    pub fn has_sound_dsp_effect(&self) -> bool {
+        self.sound_dsp_effect.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_sound_dsp_effect(&mut self, v: u32) {
+        self.sound_dsp_effect = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 num_bullets_remaining = 14;
+
+    pub fn num_bullets_remaining(&self) -> u32 {
+        self.num_bullets_remaining.unwrap_or(0)
+    }
+
+    pub fn clear_num_bullets_remaining(&mut self) {
+        self.num_bullets_remaining = ::std::option::Option::None;
+    }
+
+    pub fn has_num_bullets_remaining(&self) -> bool {
+        self.num_bullets_remaining.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_num_bullets_remaining(&mut self, v: u32) {
+        self.num_bullets_remaining = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 attack_type = 15;
+
+    pub fn attack_type(&self) -> u32 {
+        self.attack_type.unwrap_or(0)
+    }
+
+    pub fn clear_attack_type(&mut self) {
+        self.attack_type = ::std::option::Option::None;
+    }
+
+    pub fn has_attack_type(&self) -> bool {
+        self.attack_type.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_attack_type(&mut self, v: u32) {
+        self.attack_type = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CMsgTEFireBullets {
+    const NAME: &'static str = "CMsgTEFireBullets";
+
+    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.origin)?;
+                },
+                18 => {
+                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.angles)?;
+                },
+                24 => {
+                    self.weapon_id = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                32 => {
+                    self.mode = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                40 => {
+                    self.seed = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                53 => {
+                    self.player = ::std::option::Option::Some(is.read_fixed32()?);
+                },
+                61 => {
+                    self.inaccuracy = ::std::option::Option::Some(is.read_float()?);
+                },
+                69 => {
+                    self.recoil_index = ::std::option::Option::Some(is.read_float()?);
+                },
+                77 => {
+                    self.spread = ::std::option::Option::Some(is.read_float()?);
+                },
+                80 => {
+                    self.sound_type = ::std::option::Option::Some(is.read_int32()?);
+                },
+                88 => {
+                    self.item_def_index = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                101 => {
+                    self.sound_dsp_effect = ::std::option::Option::Some(is.read_fixed32()?);
+                },
+                106 => {
+                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.ent_origin)?;
+                },
+                112 => {
+                    self.num_bullets_remaining = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                120 => {
+                    self.attack_type = ::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.origin.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.angles.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.weapon_id {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
+        }
+        if let Some(v) = self.mode {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
+        }
+        if let Some(v) = self.seed {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
+        }
+        if let Some(v) = self.player {
+            my_size += 1 + 4;
+        }
+        if let Some(v) = self.inaccuracy {
+            my_size += 1 + 4;
+        }
+        if let Some(v) = self.recoil_index {
+            my_size += 1 + 4;
+        }
+        if let Some(v) = self.spread {
+            my_size += 1 + 4;
+        }
+        if let Some(v) = self.sound_type {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(10, v);
+        }
+        if let Some(v) = self.item_def_index {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(11, v);
+        }
+        if let Some(v) = self.sound_dsp_effect {
+            my_size += 1 + 4;
+        }
+        if let Some(v) = self.ent_origin.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.num_bullets_remaining {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(14, v);
+        }
+        if let Some(v) = self.attack_type {
+            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.origin.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
+        }
+        if let Some(v) = self.angles.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
+        }
+        if let Some(v) = self.weapon_id {
+            os.write_uint32(3, v)?;
+        }
+        if let Some(v) = self.mode {
+            os.write_uint32(4, v)?;
+        }
+        if let Some(v) = self.seed {
+            os.write_uint32(5, v)?;
+        }
+        if let Some(v) = self.player {
+            os.write_fixed32(6, v)?;
+        }
+        if let Some(v) = self.inaccuracy {
+            os.write_float(7, v)?;
+        }
+        if let Some(v) = self.recoil_index {
+            os.write_float(8, v)?;
+        }
+        if let Some(v) = self.spread {
+            os.write_float(9, v)?;
+        }
+        if let Some(v) = self.sound_type {
+            os.write_int32(10, v)?;
+        }
+        if let Some(v) = self.item_def_index {
+            os.write_uint32(11, v)?;
+        }
+        if let Some(v) = self.sound_dsp_effect {
+            os.write_fixed32(12, v)?;
+        }
+        if let Some(v) = self.ent_origin.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(13, v, os)?;
+        }
+        if let Some(v) = self.num_bullets_remaining {
+            os.write_uint32(14, v)?;
+        }
+        if let Some(v) = self.attack_type {
+            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() -> CMsgTEFireBullets {
+        CMsgTEFireBullets::new()
+    }
+
+    fn clear(&mut self) {
+        self.origin.clear();
+        self.angles.clear();
+        self.weapon_id = ::std::option::Option::None;
+        self.mode = ::std::option::Option::None;
+        self.seed = ::std::option::Option::None;
+        self.player = ::std::option::Option::None;
+        self.inaccuracy = ::std::option::Option::None;
+        self.recoil_index = ::std::option::Option::None;
+        self.spread = ::std::option::Option::None;
+        self.sound_type = ::std::option::Option::None;
+        self.item_def_index = ::std::option::Option::None;
+        self.sound_dsp_effect = ::std::option::Option::None;
+        self.ent_origin.clear();
+        self.num_bullets_remaining = ::std::option::Option::None;
+        self.attack_type = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CMsgTEFireBullets {
+        static instance: CMsgTEFireBullets = CMsgTEFireBullets {
+            origin: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            angles: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            weapon_id: ::std::option::Option::None,
+            mode: ::std::option::Option::None,
+            seed: ::std::option::Option::None,
+            player: ::std::option::Option::None,
+            inaccuracy: ::std::option::Option::None,
+            recoil_index: ::std::option::Option::None,
+            spread: ::std::option::Option::None,
+            sound_type: ::std::option::Option::None,
+            item_def_index: ::std::option::Option::None,
+            sound_dsp_effect: ::std::option::Option::None,
+            ent_origin: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            num_bullets_remaining: ::std::option::Option::None,
+            attack_type: ::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:ECsgoGameEvents)
+pub enum ECsgoGameEvents {
+    // @@protoc_insertion_point(enum_value:ECsgoGameEvents.GE_PlayerAnimEventId)
+    GE_PlayerAnimEventId = 450,
+    // @@protoc_insertion_point(enum_value:ECsgoGameEvents.GE_RadioIconEventId)
+    GE_RadioIconEventId = 451,
+    // @@protoc_insertion_point(enum_value:ECsgoGameEvents.GE_FireBulletsId)
+    GE_FireBulletsId = 452,
+}
+
+impl ::steam_vent_proto_common::protobuf::Enum for ECsgoGameEvents {
+    const NAME: &'static str = "ECsgoGameEvents";
+
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<ECsgoGameEvents> {
+        match value {
+            450 => ::std::option::Option::Some(ECsgoGameEvents::GE_PlayerAnimEventId),
+            451 => ::std::option::Option::Some(ECsgoGameEvents::GE_RadioIconEventId),
+            452 => ::std::option::Option::Some(ECsgoGameEvents::GE_FireBulletsId),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn from_str(str: &str) -> ::std::option::Option<ECsgoGameEvents> {
+        match str {
+            "GE_PlayerAnimEventId" => ::std::option::Option::Some(ECsgoGameEvents::GE_PlayerAnimEventId),
+            "GE_RadioIconEventId" => ::std::option::Option::Some(ECsgoGameEvents::GE_RadioIconEventId),
+            "GE_FireBulletsId" => ::std::option::Option::Some(ECsgoGameEvents::GE_FireBulletsId),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    const VALUES: &'static [ECsgoGameEvents] = &[
+        ECsgoGameEvents::GE_PlayerAnimEventId,
+        ECsgoGameEvents::GE_RadioIconEventId,
+        ECsgoGameEvents::GE_FireBulletsId,
+    ];
+}
+
+// Note, `Default` is implemented although default value is not 0
+impl ::std::default::Default for ECsgoGameEvents {
+    fn default() -> Self {
+        ECsgoGameEvents::GE_PlayerAnimEventId
+    }
+}
+
+
+
+const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;
+
+#[allow(unused_imports)]
+use crate::networkbasetypes::*;
+impl ::steam_vent_proto_common::RpcMessage for CMsgTEPlayerAnimEvent {
+    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 CMsgTERadioIcon {
+    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 CMsgTEFireBullets {
+    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
+    }
+}

src/generated/cs_usercmd.rs

@@ -0,0 +1,874 @@
+// 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 `cs_usercmd.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:CSGOInterpolationInfoPB)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CSGOInterpolationInfoPB {
+    // message fields
+    // @@protoc_insertion_point(field:CSGOInterpolationInfoPB.src_tick)
+    pub src_tick: ::std::option::Option<i32>,
+    // @@protoc_insertion_point(field:CSGOInterpolationInfoPB.dst_tick)
+    pub dst_tick: ::std::option::Option<i32>,
+    // @@protoc_insertion_point(field:CSGOInterpolationInfoPB.frac)
+    pub frac: ::std::option::Option<f32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CSGOInterpolationInfoPB.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CSGOInterpolationInfoPB {
+    fn default() -> &'a CSGOInterpolationInfoPB {
+        <CSGOInterpolationInfoPB as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CSGOInterpolationInfoPB {
+    pub fn new() -> CSGOInterpolationInfoPB {
+        ::std::default::Default::default()
+    }
+
+    // optional int32 src_tick = 1;
+
+    pub fn src_tick(&self) -> i32 {
+        self.src_tick.unwrap_or(-1i32)
+    }
+
+    pub fn clear_src_tick(&mut self) {
+        self.src_tick = ::std::option::Option::None;
+    }
+
+    pub fn has_src_tick(&self) -> bool {
+        self.src_tick.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_src_tick(&mut self, v: i32) {
+        self.src_tick = ::std::option::Option::Some(v);
+    }
+
+    // optional int32 dst_tick = 2;
+
+    pub fn dst_tick(&self) -> i32 {
+        self.dst_tick.unwrap_or(-1i32)
+    }
+
+    pub fn clear_dst_tick(&mut self) {
+        self.dst_tick = ::std::option::Option::None;
+    }
+
+    pub fn has_dst_tick(&self) -> bool {
+        self.dst_tick.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_dst_tick(&mut self, v: i32) {
+        self.dst_tick = ::std::option::Option::Some(v);
+    }
+
+    // optional float frac = 3;
+
+    pub fn frac(&self) -> f32 {
+        self.frac.unwrap_or(0.0f32)
+    }
+
+    pub fn clear_frac(&mut self) {
+        self.frac = ::std::option::Option::None;
+    }
+
+    pub fn has_frac(&self) -> bool {
+        self.frac.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_frac(&mut self, v: f32) {
+        self.frac = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CSGOInterpolationInfoPB {
+    const NAME: &'static str = "CSGOInterpolationInfoPB";
+
+    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.src_tick = ::std::option::Option::Some(is.read_int32()?);
+                },
+                16 => {
+                    self.dst_tick = ::std::option::Option::Some(is.read_int32()?);
+                },
+                29 => {
+                    self.frac = ::std::option::Option::Some(is.read_float()?);
+                },
+                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.src_tick {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
+        }
+        if let Some(v) = self.dst_tick {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
+        }
+        if let Some(v) = self.frac {
+            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.src_tick {
+            os.write_int32(1, v)?;
+        }
+        if let Some(v) = self.dst_tick {
+            os.write_int32(2, v)?;
+        }
+        if let Some(v) = self.frac {
+            os.write_float(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() -> CSGOInterpolationInfoPB {
+        CSGOInterpolationInfoPB::new()
+    }
+
+    fn clear(&mut self) {
+        self.src_tick = ::std::option::Option::None;
+        self.dst_tick = ::std::option::Option::None;
+        self.frac = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CSGOInterpolationInfoPB {
+        static instance: CSGOInterpolationInfoPB = CSGOInterpolationInfoPB {
+            src_tick: ::std::option::Option::None,
+            dst_tick: ::std::option::Option::None,
+            frac: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CSGOInputHistoryEntryPB)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CSGOInputHistoryEntryPB {
+    // message fields
+    // @@protoc_insertion_point(field:CSGOInputHistoryEntryPB.view_angles)
+    pub view_angles: ::steam_vent_proto_common::protobuf::MessageField<super::networkbasetypes::CMsgQAngle>,
+    // @@protoc_insertion_point(field:CSGOInputHistoryEntryPB.render_tick_count)
+    pub render_tick_count: ::std::option::Option<i32>,
+    // @@protoc_insertion_point(field:CSGOInputHistoryEntryPB.render_tick_fraction)
+    pub render_tick_fraction: ::std::option::Option<f32>,
+    // @@protoc_insertion_point(field:CSGOInputHistoryEntryPB.player_tick_count)
+    pub player_tick_count: ::std::option::Option<i32>,
+    // @@protoc_insertion_point(field:CSGOInputHistoryEntryPB.player_tick_fraction)
+    pub player_tick_fraction: ::std::option::Option<f32>,
+    // @@protoc_insertion_point(field:CSGOInputHistoryEntryPB.cl_interp)
+    pub cl_interp: ::steam_vent_proto_common::protobuf::MessageField<CSGOInterpolationInfoPB>,
+    // @@protoc_insertion_point(field:CSGOInputHistoryEntryPB.sv_interp0)
+    pub sv_interp0: ::steam_vent_proto_common::protobuf::MessageField<CSGOInterpolationInfoPB>,
+    // @@protoc_insertion_point(field:CSGOInputHistoryEntryPB.sv_interp1)
+    pub sv_interp1: ::steam_vent_proto_common::protobuf::MessageField<CSGOInterpolationInfoPB>,
+    // @@protoc_insertion_point(field:CSGOInputHistoryEntryPB.player_interp)
+    pub player_interp: ::steam_vent_proto_common::protobuf::MessageField<CSGOInterpolationInfoPB>,
+    // @@protoc_insertion_point(field:CSGOInputHistoryEntryPB.frame_number)
+    pub frame_number: ::std::option::Option<i32>,
+    // @@protoc_insertion_point(field:CSGOInputHistoryEntryPB.target_ent_index)
+    pub target_ent_index: ::std::option::Option<i32>,
+    // @@protoc_insertion_point(field:CSGOInputHistoryEntryPB.shoot_position)
+    pub shoot_position: ::steam_vent_proto_common::protobuf::MessageField<super::networkbasetypes::CMsgVector>,
+    // @@protoc_insertion_point(field:CSGOInputHistoryEntryPB.target_head_pos_check)
+    pub target_head_pos_check: ::steam_vent_proto_common::protobuf::MessageField<super::networkbasetypes::CMsgVector>,
+    // @@protoc_insertion_point(field:CSGOInputHistoryEntryPB.target_abs_pos_check)
+    pub target_abs_pos_check: ::steam_vent_proto_common::protobuf::MessageField<super::networkbasetypes::CMsgVector>,
+    // @@protoc_insertion_point(field:CSGOInputHistoryEntryPB.target_abs_ang_check)
+    pub target_abs_ang_check: ::steam_vent_proto_common::protobuf::MessageField<super::networkbasetypes::CMsgQAngle>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CSGOInputHistoryEntryPB.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CSGOInputHistoryEntryPB {
+    fn default() -> &'a CSGOInputHistoryEntryPB {
+        <CSGOInputHistoryEntryPB as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CSGOInputHistoryEntryPB {
+    pub fn new() -> CSGOInputHistoryEntryPB {
+        ::std::default::Default::default()
+    }
+
+    // optional int32 render_tick_count = 4;
+
+    pub fn render_tick_count(&self) -> i32 {
+        self.render_tick_count.unwrap_or(0)
+    }
+
+    pub fn clear_render_tick_count(&mut self) {
+        self.render_tick_count = ::std::option::Option::None;
+    }
+
+    pub fn has_render_tick_count(&self) -> bool {
+        self.render_tick_count.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_render_tick_count(&mut self, v: i32) {
+        self.render_tick_count = ::std::option::Option::Some(v);
+    }
+
+    // optional float render_tick_fraction = 5;
+
+    pub fn render_tick_fraction(&self) -> f32 {
+        self.render_tick_fraction.unwrap_or(0.)
+    }
+
+    pub fn clear_render_tick_fraction(&mut self) {
+        self.render_tick_fraction = ::std::option::Option::None;
+    }
+
+    pub fn has_render_tick_fraction(&self) -> bool {
+        self.render_tick_fraction.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_render_tick_fraction(&mut self, v: f32) {
+        self.render_tick_fraction = ::std::option::Option::Some(v);
+    }
+
+    // optional int32 player_tick_count = 6;
+
+    pub fn player_tick_count(&self) -> i32 {
+        self.player_tick_count.unwrap_or(0)
+    }
+
+    pub fn clear_player_tick_count(&mut self) {
+        self.player_tick_count = ::std::option::Option::None;
+    }
+
+    pub fn has_player_tick_count(&self) -> bool {
+        self.player_tick_count.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_player_tick_count(&mut self, v: i32) {
+        self.player_tick_count = ::std::option::Option::Some(v);
+    }
+
+    // optional float player_tick_fraction = 7;
+
+    pub fn player_tick_fraction(&self) -> f32 {
+        self.player_tick_fraction.unwrap_or(0.)
+    }
+
+    pub fn clear_player_tick_fraction(&mut self) {
+        self.player_tick_fraction = ::std::option::Option::None;
+    }
+
+    pub fn has_player_tick_fraction(&self) -> bool {
+        self.player_tick_fraction.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_player_tick_fraction(&mut self, v: f32) {
+        self.player_tick_fraction = ::std::option::Option::Some(v);
+    }
+
+    // optional int32 frame_number = 20;
+
+    pub fn frame_number(&self) -> i32 {
+        self.frame_number.unwrap_or(0)
+    }
+
+    pub fn clear_frame_number(&mut self) {
+        self.frame_number = ::std::option::Option::None;
+    }
+
+    pub fn has_frame_number(&self) -> bool {
+        self.frame_number.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_frame_number(&mut self, v: i32) {
+        self.frame_number = ::std::option::Option::Some(v);
+    }
+
+    // optional int32 target_ent_index = 8;
+
+    pub fn target_ent_index(&self) -> i32 {
+        self.target_ent_index.unwrap_or(-1i32)
+    }
+
+    pub fn clear_target_ent_index(&mut self) {
+        self.target_ent_index = ::std::option::Option::None;
+    }
+
+    pub fn has_target_ent_index(&self) -> bool {
+        self.target_ent_index.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_target_ent_index(&mut self, v: i32) {
+        self.target_ent_index = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CSGOInputHistoryEntryPB {
+    const NAME: &'static str = "CSGOInputHistoryEntryPB";
+
+    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.view_angles)?;
+                },
+                32 => {
+                    self.render_tick_count = ::std::option::Option::Some(is.read_int32()?);
+                },
+                45 => {
+                    self.render_tick_fraction = ::std::option::Option::Some(is.read_float()?);
+                },
+                48 => {
+                    self.player_tick_count = ::std::option::Option::Some(is.read_int32()?);
+                },
+                61 => {
+                    self.player_tick_fraction = ::std::option::Option::Some(is.read_float()?);
+                },
+                98 => {
+                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.cl_interp)?;
+                },
+                106 => {
+                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.sv_interp0)?;
+                },
+                114 => {
+                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.sv_interp1)?;
+                },
+                122 => {
+                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.player_interp)?;
+                },
+                160 => {
+                    self.frame_number = ::std::option::Option::Some(is.read_int32()?);
+                },
+                64 => {
+                    self.target_ent_index = ::std::option::Option::Some(is.read_int32()?);
+                },
+                26 => {
+                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.shoot_position)?;
+                },
+                74 => {
+                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.target_head_pos_check)?;
+                },
+                82 => {
+                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.target_abs_pos_check)?;
+                },
+                90 => {
+                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.target_abs_ang_check)?;
+                },
+                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.view_angles.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.render_tick_count {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v);
+        }
+        if let Some(v) = self.render_tick_fraction {
+            my_size += 1 + 4;
+        }
+        if let Some(v) = self.player_tick_count {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(6, v);
+        }
+        if let Some(v) = self.player_tick_fraction {
+            my_size += 1 + 4;
+        }
+        if let Some(v) = self.cl_interp.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.sv_interp0.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.sv_interp1.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.player_interp.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.frame_number {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(20, v);
+        }
+        if let Some(v) = self.target_ent_index {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(8, v);
+        }
+        if let Some(v) = self.shoot_position.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.target_head_pos_check.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.target_abs_pos_check.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.target_abs_ang_check.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.view_angles.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
+        }
+        if let Some(v) = self.render_tick_count {
+            os.write_int32(4, v)?;
+        }
+        if let Some(v) = self.render_tick_fraction {
+            os.write_float(5, v)?;
+        }
+        if let Some(v) = self.player_tick_count {
+            os.write_int32(6, v)?;
+        }
+        if let Some(v) = self.player_tick_fraction {
+            os.write_float(7, v)?;
+        }
+        if let Some(v) = self.cl_interp.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(12, v, os)?;
+        }
+        if let Some(v) = self.sv_interp0.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(13, v, os)?;
+        }
+        if let Some(v) = self.sv_interp1.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(14, v, os)?;
+        }
+        if let Some(v) = self.player_interp.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(15, v, os)?;
+        }
+        if let Some(v) = self.frame_number {
+            os.write_int32(20, v)?;
+        }
+        if let Some(v) = self.target_ent_index {
+            os.write_int32(8, v)?;
+        }
+        if let Some(v) = self.shoot_position.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
+        }
+        if let Some(v) = self.target_head_pos_check.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
+        }
+        if let Some(v) = self.target_abs_pos_check.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
+        }
+        if let Some(v) = self.target_abs_ang_check.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(11, 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() -> CSGOInputHistoryEntryPB {
+        CSGOInputHistoryEntryPB::new()
+    }
+
+    fn clear(&mut self) {
+        self.view_angles.clear();
+        self.render_tick_count = ::std::option::Option::None;
+        self.render_tick_fraction = ::std::option::Option::None;
+        self.player_tick_count = ::std::option::Option::None;
+        self.player_tick_fraction = ::std::option::Option::None;
+        self.cl_interp.clear();
+        self.sv_interp0.clear();
+        self.sv_interp1.clear();
+        self.player_interp.clear();
+        self.frame_number = ::std::option::Option::None;
+        self.target_ent_index = ::std::option::Option::None;
+        self.shoot_position.clear();
+        self.target_head_pos_check.clear();
+        self.target_abs_pos_check.clear();
+        self.target_abs_ang_check.clear();
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CSGOInputHistoryEntryPB {
+        static instance: CSGOInputHistoryEntryPB = CSGOInputHistoryEntryPB {
+            view_angles: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            render_tick_count: ::std::option::Option::None,
+            render_tick_fraction: ::std::option::Option::None,
+            player_tick_count: ::std::option::Option::None,
+            player_tick_fraction: ::std::option::Option::None,
+            cl_interp: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            sv_interp0: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            sv_interp1: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            player_interp: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            frame_number: ::std::option::Option::None,
+            target_ent_index: ::std::option::Option::None,
+            shoot_position: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            target_head_pos_check: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            target_abs_pos_check: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            target_abs_ang_check: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CSGOUserCmdPB)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CSGOUserCmdPB {
+    // message fields
+    // @@protoc_insertion_point(field:CSGOUserCmdPB.base)
+    pub base: ::steam_vent_proto_common::protobuf::MessageField<super::usercmd::CBaseUserCmdPB>,
+    // @@protoc_insertion_point(field:CSGOUserCmdPB.input_history)
+    pub input_history: ::std::vec::Vec<CSGOInputHistoryEntryPB>,
+    // @@protoc_insertion_point(field:CSGOUserCmdPB.attack1_start_history_index)
+    pub attack1_start_history_index: ::std::option::Option<i32>,
+    // @@protoc_insertion_point(field:CSGOUserCmdPB.attack2_start_history_index)
+    pub attack2_start_history_index: ::std::option::Option<i32>,
+    // @@protoc_insertion_point(field:CSGOUserCmdPB.attack3_start_history_index)
+    pub attack3_start_history_index: ::std::option::Option<i32>,
+    // @@protoc_insertion_point(field:CSGOUserCmdPB.left_hand_desired)
+    pub left_hand_desired: ::std::option::Option<bool>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CSGOUserCmdPB.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CSGOUserCmdPB {
+    fn default() -> &'a CSGOUserCmdPB {
+        <CSGOUserCmdPB as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CSGOUserCmdPB {
+    pub fn new() -> CSGOUserCmdPB {
+        ::std::default::Default::default()
+    }
+
+    // optional int32 attack1_start_history_index = 6;
+
+    pub fn attack1_start_history_index(&self) -> i32 {
+        self.attack1_start_history_index.unwrap_or(-1i32)
+    }
+
+    pub fn clear_attack1_start_history_index(&mut self) {
+        self.attack1_start_history_index = ::std::option::Option::None;
+    }
+
+    pub fn has_attack1_start_history_index(&self) -> bool {
+        self.attack1_start_history_index.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_attack1_start_history_index(&mut self, v: i32) {
+        self.attack1_start_history_index = ::std::option::Option::Some(v);
+    }
+
+    // optional int32 attack2_start_history_index = 7;
+
+    pub fn attack2_start_history_index(&self) -> i32 {
+        self.attack2_start_history_index.unwrap_or(-1i32)
+    }
+
+    pub fn clear_attack2_start_history_index(&mut self) {
+        self.attack2_start_history_index = ::std::option::Option::None;
+    }
+
+    pub fn has_attack2_start_history_index(&self) -> bool {
+        self.attack2_start_history_index.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_attack2_start_history_index(&mut self, v: i32) {
+        self.attack2_start_history_index = ::std::option::Option::Some(v);
+    }
+
+    // optional int32 attack3_start_history_index = 8;
+
+    pub fn attack3_start_history_index(&self) -> i32 {
+        self.attack3_start_history_index.unwrap_or(-1i32)
+    }
+
+    pub fn clear_attack3_start_history_index(&mut self) {
+        self.attack3_start_history_index = ::std::option::Option::None;
+    }
+
+    pub fn has_attack3_start_history_index(&self) -> bool {
+        self.attack3_start_history_index.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_attack3_start_history_index(&mut self, v: i32) {
+        self.attack3_start_history_index = ::std::option::Option::Some(v);
+    }
+
+    // optional bool left_hand_desired = 9;
+
+    pub fn left_hand_desired(&self) -> bool {
+        self.left_hand_desired.unwrap_or(false)
+    }
+
+    pub fn clear_left_hand_desired(&mut self) {
+        self.left_hand_desired = ::std::option::Option::None;
+    }
+
+    pub fn has_left_hand_desired(&self) -> bool {
+        self.left_hand_desired.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_left_hand_desired(&mut self, v: bool) {
+        self.left_hand_desired = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CSGOUserCmdPB {
+    const NAME: &'static str = "CSGOUserCmdPB";
+
+    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.base)?;
+                },
+                18 => {
+                    self.input_history.push(is.read_message()?);
+                },
+                48 => {
+                    self.attack1_start_history_index = ::std::option::Option::Some(is.read_int32()?);
+                },
+                56 => {
+                    self.attack2_start_history_index = ::std::option::Option::Some(is.read_int32()?);
+                },
+                64 => {
+                    self.attack3_start_history_index = ::std::option::Option::Some(is.read_int32()?);
+                },
+                72 => {
+                    self.left_hand_desired = ::std::option::Option::Some(is.read_bool()?);
+                },
+                tag => {
+                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u64 {
+        let mut my_size = 0;
+        if let Some(v) = self.base.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.input_history {
+            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.attack1_start_history_index {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(6, v);
+        }
+        if let Some(v) = self.attack2_start_history_index {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(7, v);
+        }
+        if let Some(v) = self.attack3_start_history_index {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(8, v);
+        }
+        if let Some(v) = self.left_hand_desired {
+            my_size += 1 + 1;
+        }
+        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        if let Some(v) = self.base.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
+        }
+        for v in &self.input_history {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
+        };
+        if let Some(v) = self.attack1_start_history_index {
+            os.write_int32(6, v)?;
+        }
+        if let Some(v) = self.attack2_start_history_index {
+            os.write_int32(7, v)?;
+        }
+        if let Some(v) = self.attack3_start_history_index {
+            os.write_int32(8, v)?;
+        }
+        if let Some(v) = self.left_hand_desired {
+            os.write_bool(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() -> CSGOUserCmdPB {
+        CSGOUserCmdPB::new()
+    }
+
+    fn clear(&mut self) {
+        self.base.clear();
+        self.input_history.clear();
+        self.attack1_start_history_index = ::std::option::Option::None;
+        self.attack2_start_history_index = ::std::option::Option::None;
+        self.attack3_start_history_index = ::std::option::Option::None;
+        self.left_hand_desired = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CSGOUserCmdPB {
+        static instance: CSGOUserCmdPB = CSGOUserCmdPB {
+            base: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            input_history: ::std::vec::Vec::new(),
+            attack1_start_history_index: ::std::option::Option::None,
+            attack2_start_history_index: ::std::option::Option::None,
+            attack3_start_history_index: ::std::option::Option::None,
+            left_hand_desired: ::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::networkbasetypes::*;
+#[allow(unused_imports)]
+use crate::usercmd::*;
+impl ::steam_vent_proto_common::RpcMessage for CSGOInterpolationInfoPB {
+    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 CSGOInputHistoryEntryPB {
+    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 CSGOUserCmdPB {
+    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
+    }
+}

src/generated/engine_gcmessages.rs

@@ -0,0 +1,440 @@
+// 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 `engine_gcmessages.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:CEngineGotvSyncPacket)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CEngineGotvSyncPacket {
+    // message fields
+    // @@protoc_insertion_point(field:CEngineGotvSyncPacket.match_id)
+    pub match_id: ::std::option::Option<u64>,
+    // @@protoc_insertion_point(field:CEngineGotvSyncPacket.instance_id)
+    pub instance_id: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CEngineGotvSyncPacket.signupfragment)
+    pub signupfragment: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CEngineGotvSyncPacket.currentfragment)
+    pub currentfragment: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CEngineGotvSyncPacket.tickrate)
+    pub tickrate: ::std::option::Option<f32>,
+    // @@protoc_insertion_point(field:CEngineGotvSyncPacket.tick)
+    pub tick: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CEngineGotvSyncPacket.rtdelay)
+    pub rtdelay: ::std::option::Option<f32>,
+    // @@protoc_insertion_point(field:CEngineGotvSyncPacket.rcvage)
+    pub rcvage: ::std::option::Option<f32>,
+    // @@protoc_insertion_point(field:CEngineGotvSyncPacket.keyframe_interval)
+    pub keyframe_interval: ::std::option::Option<f32>,
+    // @@protoc_insertion_point(field:CEngineGotvSyncPacket.cdndelay)
+    pub cdndelay: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CEngineGotvSyncPacket.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CEngineGotvSyncPacket {
+    fn default() -> &'a CEngineGotvSyncPacket {
+        <CEngineGotvSyncPacket as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CEngineGotvSyncPacket {
+    pub fn new() -> CEngineGotvSyncPacket {
+        ::std::default::Default::default()
+    }
+
+    // optional uint64 match_id = 1;
+
+    pub fn match_id(&self) -> u64 {
+        self.match_id.unwrap_or(0)
+    }
+
+    pub fn clear_match_id(&mut self) {
+        self.match_id = ::std::option::Option::None;
+    }
+
+    pub fn has_match_id(&self) -> bool {
+        self.match_id.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_match_id(&mut self, v: u64) {
+        self.match_id = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 instance_id = 2;
+
+    pub fn instance_id(&self) -> u32 {
+        self.instance_id.unwrap_or(0)
+    }
+
+    pub fn clear_instance_id(&mut self) {
+        self.instance_id = ::std::option::Option::None;
+    }
+
+    pub fn has_instance_id(&self) -> bool {
+        self.instance_id.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_instance_id(&mut self, v: u32) {
+        self.instance_id = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 signupfragment = 3;
+
+    pub fn signupfragment(&self) -> u32 {
+        self.signupfragment.unwrap_or(0)
+    }
+
+    pub fn clear_signupfragment(&mut self) {
+        self.signupfragment = ::std::option::Option::None;
+    }
+
+    pub fn has_signupfragment(&self) -> bool {
+        self.signupfragment.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_signupfragment(&mut self, v: u32) {
+        self.signupfragment = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 currentfragment = 4;
+
+    pub fn currentfragment(&self) -> u32 {
+        self.currentfragment.unwrap_or(0)
+    }
+
+    pub fn clear_currentfragment(&mut self) {
+        self.currentfragment = ::std::option::Option::None;
+    }
+
+    pub fn has_currentfragment(&self) -> bool {
+        self.currentfragment.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_currentfragment(&mut self, v: u32) {
+        self.currentfragment = ::std::option::Option::Some(v);
+    }
+
+    // optional float tickrate = 5;
+
+    pub fn tickrate(&self) -> f32 {
+        self.tickrate.unwrap_or(0.)
+    }
+
+    pub fn clear_tickrate(&mut self) {
+        self.tickrate = ::std::option::Option::None;
+    }
+
+    pub fn has_tickrate(&self) -> bool {
+        self.tickrate.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_tickrate(&mut self, v: f32) {
+        self.tickrate = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 tick = 6;
+
+    pub fn tick(&self) -> u32 {
+        self.tick.unwrap_or(0)
+    }
+
+    pub fn clear_tick(&mut self) {
+        self.tick = ::std::option::Option::None;
+    }
+
+    pub fn has_tick(&self) -> bool {
+        self.tick.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_tick(&mut self, v: u32) {
+        self.tick = ::std::option::Option::Some(v);
+    }
+
+    // optional float rtdelay = 8;
+
+    pub fn rtdelay(&self) -> f32 {
+        self.rtdelay.unwrap_or(0.)
+    }
+
+    pub fn clear_rtdelay(&mut self) {
+        self.rtdelay = ::std::option::Option::None;
+    }
+
+    pub fn has_rtdelay(&self) -> bool {
+        self.rtdelay.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_rtdelay(&mut self, v: f32) {
+        self.rtdelay = ::std::option::Option::Some(v);
+    }
+
+    // optional float rcvage = 9;
+
+    pub fn rcvage(&self) -> f32 {
+        self.rcvage.unwrap_or(0.)
+    }
+
+    pub fn clear_rcvage(&mut self) {
+        self.rcvage = ::std::option::Option::None;
+    }
+
+    pub fn has_rcvage(&self) -> bool {
+        self.rcvage.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_rcvage(&mut self, v: f32) {
+        self.rcvage = ::std::option::Option::Some(v);
+    }
+
+    // optional float keyframe_interval = 10;
+
+    pub fn keyframe_interval(&self) -> f32 {
+        self.keyframe_interval.unwrap_or(0.)
+    }
+
+    pub fn clear_keyframe_interval(&mut self) {
+        self.keyframe_interval = ::std::option::Option::None;
+    }
+
+    pub fn has_keyframe_interval(&self) -> bool {
+        self.keyframe_interval.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_keyframe_interval(&mut self, v: f32) {
+        self.keyframe_interval = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 cdndelay = 11;
+
+    pub fn cdndelay(&self) -> u32 {
+        self.cdndelay.unwrap_or(0)
+    }
+
+    pub fn clear_cdndelay(&mut self) {
+        self.cdndelay = ::std::option::Option::None;
+    }
+
+    pub fn has_cdndelay(&self) -> bool {
+        self.cdndelay.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_cdndelay(&mut self, v: u32) {
+        self.cdndelay = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CEngineGotvSyncPacket {
+    const NAME: &'static str = "CEngineGotvSyncPacket";
+
+    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.match_id = ::std::option::Option::Some(is.read_uint64()?);
+                },
+                16 => {
+                    self.instance_id = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                24 => {
+                    self.signupfragment = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                32 => {
+                    self.currentfragment = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                45 => {
+                    self.tickrate = ::std::option::Option::Some(is.read_float()?);
+                },
+                48 => {
+                    self.tick = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                69 => {
+                    self.rtdelay = ::std::option::Option::Some(is.read_float()?);
+                },
+                77 => {
+                    self.rcvage = ::std::option::Option::Some(is.read_float()?);
+                },
+                85 => {
+                    self.keyframe_interval = ::std::option::Option::Some(is.read_float()?);
+                },
+                88 => {
+                    self.cdndelay = ::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.match_id {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
+        }
+        if let Some(v) = self.instance_id {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
+        }
+        if let Some(v) = self.signupfragment {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
+        }
+        if let Some(v) = self.currentfragment {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
+        }
+        if let Some(v) = self.tickrate {
+            my_size += 1 + 4;
+        }
+        if let Some(v) = self.tick {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
+        }
+        if let Some(v) = self.rtdelay {
+            my_size += 1 + 4;
+        }
+        if let Some(v) = self.rcvage {
+            my_size += 1 + 4;
+        }
+        if let Some(v) = self.keyframe_interval {
+            my_size += 1 + 4;
+        }
+        if let Some(v) = self.cdndelay {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(11, 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.match_id {
+            os.write_uint64(1, v)?;
+        }
+        if let Some(v) = self.instance_id {
+            os.write_uint32(2, v)?;
+        }
+        if let Some(v) = self.signupfragment {
+            os.write_uint32(3, v)?;
+        }
+        if let Some(v) = self.currentfragment {
+            os.write_uint32(4, v)?;
+        }
+        if let Some(v) = self.tickrate {
+            os.write_float(5, v)?;
+        }
+        if let Some(v) = self.tick {
+            os.write_uint32(6, v)?;
+        }
+        if let Some(v) = self.rtdelay {
+            os.write_float(8, v)?;
+        }
+        if let Some(v) = self.rcvage {
+            os.write_float(9, v)?;
+        }
+        if let Some(v) = self.keyframe_interval {
+            os.write_float(10, v)?;
+        }
+        if let Some(v) = self.cdndelay {
+            os.write_uint32(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() -> CEngineGotvSyncPacket {
+        CEngineGotvSyncPacket::new()
+    }
+
+    fn clear(&mut self) {
+        self.match_id = ::std::option::Option::None;
+        self.instance_id = ::std::option::Option::None;
+        self.signupfragment = ::std::option::Option::None;
+        self.currentfragment = ::std::option::Option::None;
+        self.tickrate = ::std::option::Option::None;
+        self.tick = ::std::option::Option::None;
+        self.rtdelay = ::std::option::Option::None;
+        self.rcvage = ::std::option::Option::None;
+        self.keyframe_interval = ::std::option::Option::None;
+        self.cdndelay = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CEngineGotvSyncPacket {
+        static instance: CEngineGotvSyncPacket = CEngineGotvSyncPacket {
+            match_id: ::std::option::Option::None,
+            instance_id: ::std::option::Option::None,
+            signupfragment: ::std::option::Option::None,
+            currentfragment: ::std::option::Option::None,
+            tickrate: ::std::option::Option::None,
+            tick: ::std::option::Option::None,
+            rtdelay: ::std::option::Option::None,
+            rcvage: ::std::option::Option::None,
+            keyframe_interval: ::std::option::Option::None,
+            cdndelay: ::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;
+
+impl ::steam_vent_proto_common::RpcMessage for CEngineGotvSyncPacket {
+    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
+    }
+}

src/generated/mod.rs

@@ -0,0 +1,42 @@
+// @generated
+
+pub mod base_gcmessages;
+pub mod base_gcmessages_csgo;
+pub mod c_peer2peer_netmessages;
+pub mod clientmessages;
+pub mod connectionless_netmessages;
+pub mod cs_gameevents;
+pub mod cs_usercmd;
+pub mod cstrike15_gcmessages;
+pub mod cstrike15_usermessages;
+pub mod demo;
+pub mod econ_gcmessages;
+pub mod engine_gcmessages;
+pub mod enums_clientserver;
+pub mod fatdemo;
+pub mod gameevents;
+pub mod gcsdk_gcmessages;
+pub mod gcsystemmsgs;
+pub mod netmessages;
+pub mod network_connection;
+pub mod networkbasetypes;
+pub mod networksystem_protomessages;
+pub mod steamdatagram_messages_auth;
+pub mod steamdatagram_messages_sdr;
+pub mod steammessages;
+pub mod steammessages_base;
+pub mod steammessages_cloud_steamworkssdk;
+pub mod steammessages_gamenetworkingui;
+pub mod steammessages_helprequest_steamworkssdk;
+pub mod steammessages_oauth_steamworkssdk;
+pub mod steammessages_player_steamworkssdk;
+pub mod steammessages_publishedfile_steamworkssdk;
+pub mod steammessages_unified_base_steamworkssdk;
+pub mod steamnetworkingsockets_messages;
+pub mod steamnetworkingsockets_messages_certs;
+pub mod steamnetworkingsockets_messages_udp;
+pub mod te;
+pub mod uifontfile_format;
+pub mod usercmd;
+pub mod usermessages;
+pub mod valveextensions;

src/generated/network_connection.rs

@@ -0,0 +1,656 @@
+// 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 `network_connection.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;
+
+#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
+// @@protoc_insertion_point(enum:ENetworkDisconnectionReason)
+pub enum ENetworkDisconnectionReason {
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_INVALID)
+    NETWORK_DISCONNECT_INVALID = 0,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_SHUTDOWN)
+    NETWORK_DISCONNECT_SHUTDOWN = 1,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_DISCONNECT_BY_USER)
+    NETWORK_DISCONNECT_DISCONNECT_BY_USER = 2,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_DISCONNECT_BY_SERVER)
+    NETWORK_DISCONNECT_DISCONNECT_BY_SERVER = 3,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_LOST)
+    NETWORK_DISCONNECT_LOST = 4,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_OVERFLOW)
+    NETWORK_DISCONNECT_OVERFLOW = 5,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_STEAM_BANNED)
+    NETWORK_DISCONNECT_STEAM_BANNED = 6,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_STEAM_INUSE)
+    NETWORK_DISCONNECT_STEAM_INUSE = 7,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_STEAM_TICKET)
+    NETWORK_DISCONNECT_STEAM_TICKET = 8,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_STEAM_LOGON)
+    NETWORK_DISCONNECT_STEAM_LOGON = 9,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_STEAM_AUTHCANCELLED)
+    NETWORK_DISCONNECT_STEAM_AUTHCANCELLED = 10,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_STEAM_AUTHALREADYUSED)
+    NETWORK_DISCONNECT_STEAM_AUTHALREADYUSED = 11,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_STEAM_AUTHINVALID)
+    NETWORK_DISCONNECT_STEAM_AUTHINVALID = 12,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_STEAM_VACBANSTATE)
+    NETWORK_DISCONNECT_STEAM_VACBANSTATE = 13,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_STEAM_LOGGED_IN_ELSEWHERE)
+    NETWORK_DISCONNECT_STEAM_LOGGED_IN_ELSEWHERE = 14,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_STEAM_VAC_CHECK_TIMEDOUT)
+    NETWORK_DISCONNECT_STEAM_VAC_CHECK_TIMEDOUT = 15,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_STEAM_DROPPED)
+    NETWORK_DISCONNECT_STEAM_DROPPED = 16,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_STEAM_OWNERSHIP)
+    NETWORK_DISCONNECT_STEAM_OWNERSHIP = 17,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_SERVERINFO_OVERFLOW)
+    NETWORK_DISCONNECT_SERVERINFO_OVERFLOW = 18,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_TICKMSG_OVERFLOW)
+    NETWORK_DISCONNECT_TICKMSG_OVERFLOW = 19,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_STRINGTABLEMSG_OVERFLOW)
+    NETWORK_DISCONNECT_STRINGTABLEMSG_OVERFLOW = 20,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_DELTAENTMSG_OVERFLOW)
+    NETWORK_DISCONNECT_DELTAENTMSG_OVERFLOW = 21,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_TEMPENTMSG_OVERFLOW)
+    NETWORK_DISCONNECT_TEMPENTMSG_OVERFLOW = 22,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_SOUNDSMSG_OVERFLOW)
+    NETWORK_DISCONNECT_SOUNDSMSG_OVERFLOW = 23,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_SNAPSHOTOVERFLOW)
+    NETWORK_DISCONNECT_SNAPSHOTOVERFLOW = 24,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_SNAPSHOTERROR)
+    NETWORK_DISCONNECT_SNAPSHOTERROR = 25,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_RELIABLEOVERFLOW)
+    NETWORK_DISCONNECT_RELIABLEOVERFLOW = 26,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_BADDELTATICK)
+    NETWORK_DISCONNECT_BADDELTATICK = 27,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_NOMORESPLITS)
+    NETWORK_DISCONNECT_NOMORESPLITS = 28,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_TIMEDOUT)
+    NETWORK_DISCONNECT_TIMEDOUT = 29,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_DISCONNECTED)
+    NETWORK_DISCONNECT_DISCONNECTED = 30,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_LEAVINGSPLIT)
+    NETWORK_DISCONNECT_LEAVINGSPLIT = 31,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_DIFFERENTCLASSTABLES)
+    NETWORK_DISCONNECT_DIFFERENTCLASSTABLES = 32,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_BADRELAYPASSWORD)
+    NETWORK_DISCONNECT_BADRELAYPASSWORD = 33,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_BADSPECTATORPASSWORD)
+    NETWORK_DISCONNECT_BADSPECTATORPASSWORD = 34,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_HLTVRESTRICTED)
+    NETWORK_DISCONNECT_HLTVRESTRICTED = 35,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_NOSPECTATORS)
+    NETWORK_DISCONNECT_NOSPECTATORS = 36,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_HLTVUNAVAILABLE)
+    NETWORK_DISCONNECT_HLTVUNAVAILABLE = 37,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_HLTVSTOP)
+    NETWORK_DISCONNECT_HLTVSTOP = 38,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_KICKED)
+    NETWORK_DISCONNECT_KICKED = 39,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_BANADDED)
+    NETWORK_DISCONNECT_BANADDED = 40,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_KICKBANADDED)
+    NETWORK_DISCONNECT_KICKBANADDED = 41,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_HLTVDIRECT)
+    NETWORK_DISCONNECT_HLTVDIRECT = 42,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_PURESERVER_CLIENTEXTRA)
+    NETWORK_DISCONNECT_PURESERVER_CLIENTEXTRA = 43,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_PURESERVER_MISMATCH)
+    NETWORK_DISCONNECT_PURESERVER_MISMATCH = 44,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_USERCMD)
+    NETWORK_DISCONNECT_USERCMD = 45,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECTED_BY_GAME)
+    NETWORK_DISCONNECT_REJECTED_BY_GAME = 46,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_MESSAGE_PARSE_ERROR)
+    NETWORK_DISCONNECT_MESSAGE_PARSE_ERROR = 47,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_INVALID_MESSAGE_ERROR)
+    NETWORK_DISCONNECT_INVALID_MESSAGE_ERROR = 48,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_BAD_SERVER_PASSWORD)
+    NETWORK_DISCONNECT_BAD_SERVER_PASSWORD = 49,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_DIRECT_CONNECT_RESERVATION)
+    NETWORK_DISCONNECT_DIRECT_CONNECT_RESERVATION = 50,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_CONNECTION_FAILURE)
+    NETWORK_DISCONNECT_CONNECTION_FAILURE = 51,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_NO_PEER_GROUP_HANDLERS)
+    NETWORK_DISCONNECT_NO_PEER_GROUP_HANDLERS = 52,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_RECONNECTION)
+    NETWORK_DISCONNECT_RECONNECTION = 53,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_LOOPSHUTDOWN)
+    NETWORK_DISCONNECT_LOOPSHUTDOWN = 54,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_LOOPDEACTIVATE)
+    NETWORK_DISCONNECT_LOOPDEACTIVATE = 55,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_HOST_ENDGAME)
+    NETWORK_DISCONNECT_HOST_ENDGAME = 56,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_LOOP_LEVELLOAD_ACTIVATE)
+    NETWORK_DISCONNECT_LOOP_LEVELLOAD_ACTIVATE = 57,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_CREATE_SERVER_FAILED)
+    NETWORK_DISCONNECT_CREATE_SERVER_FAILED = 58,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_EXITING)
+    NETWORK_DISCONNECT_EXITING = 59,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REQUEST_HOSTSTATE_IDLE)
+    NETWORK_DISCONNECT_REQUEST_HOSTSTATE_IDLE = 60,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REQUEST_HOSTSTATE_HLTVRELAY)
+    NETWORK_DISCONNECT_REQUEST_HOSTSTATE_HLTVRELAY = 61,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_CLIENT_CONSISTENCY_FAIL)
+    NETWORK_DISCONNECT_CLIENT_CONSISTENCY_FAIL = 62,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_CLIENT_UNABLE_TO_CRC_MAP)
+    NETWORK_DISCONNECT_CLIENT_UNABLE_TO_CRC_MAP = 63,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_CLIENT_NO_MAP)
+    NETWORK_DISCONNECT_CLIENT_NO_MAP = 64,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_CLIENT_DIFFERENT_MAP)
+    NETWORK_DISCONNECT_CLIENT_DIFFERENT_MAP = 65,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_SERVER_REQUIRES_STEAM)
+    NETWORK_DISCONNECT_SERVER_REQUIRES_STEAM = 66,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_STEAM_DENY_MISC)
+    NETWORK_DISCONNECT_STEAM_DENY_MISC = 67,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_STEAM_DENY_BAD_ANTI_CHEAT)
+    NETWORK_DISCONNECT_STEAM_DENY_BAD_ANTI_CHEAT = 68,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_SERVER_SHUTDOWN)
+    NETWORK_DISCONNECT_SERVER_SHUTDOWN = 69,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REPLAY_INCOMPATIBLE)
+    NETWORK_DISCONNECT_REPLAY_INCOMPATIBLE = 71,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_CONNECT_REQUEST_TIMEDOUT)
+    NETWORK_DISCONNECT_CONNECT_REQUEST_TIMEDOUT = 72,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_SERVER_INCOMPATIBLE)
+    NETWORK_DISCONNECT_SERVER_INCOMPATIBLE = 73,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_LOCALPROBLEM_MANYRELAYS)
+    NETWORK_DISCONNECT_LOCALPROBLEM_MANYRELAYS = 74,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_LOCALPROBLEM_HOSTEDSERVERPRIMARYRELAY)
+    NETWORK_DISCONNECT_LOCALPROBLEM_HOSTEDSERVERPRIMARYRELAY = 75,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_LOCALPROBLEM_NETWORKCONFIG)
+    NETWORK_DISCONNECT_LOCALPROBLEM_NETWORKCONFIG = 76,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_LOCALPROBLEM_OTHER)
+    NETWORK_DISCONNECT_LOCALPROBLEM_OTHER = 77,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REMOTE_TIMEOUT)
+    NETWORK_DISCONNECT_REMOTE_TIMEOUT = 79,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REMOTE_TIMEOUT_CONNECTING)
+    NETWORK_DISCONNECT_REMOTE_TIMEOUT_CONNECTING = 80,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REMOTE_OTHER)
+    NETWORK_DISCONNECT_REMOTE_OTHER = 81,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REMOTE_BADCRYPT)
+    NETWORK_DISCONNECT_REMOTE_BADCRYPT = 82,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REMOTE_CERTNOTTRUSTED)
+    NETWORK_DISCONNECT_REMOTE_CERTNOTTRUSTED = 83,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_UNUSUAL)
+    NETWORK_DISCONNECT_UNUSUAL = 84,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_INTERNAL_ERROR)
+    NETWORK_DISCONNECT_INTERNAL_ERROR = 85,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_BADCHALLENGE)
+    NETWORK_DISCONNECT_REJECT_BADCHALLENGE = 128,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_NOLOBBY)
+    NETWORK_DISCONNECT_REJECT_NOLOBBY = 129,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_BACKGROUND_MAP)
+    NETWORK_DISCONNECT_REJECT_BACKGROUND_MAP = 130,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_SINGLE_PLAYER)
+    NETWORK_DISCONNECT_REJECT_SINGLE_PLAYER = 131,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_HIDDEN_GAME)
+    NETWORK_DISCONNECT_REJECT_HIDDEN_GAME = 132,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_LANRESTRICT)
+    NETWORK_DISCONNECT_REJECT_LANRESTRICT = 133,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_BADPASSWORD)
+    NETWORK_DISCONNECT_REJECT_BADPASSWORD = 134,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_SERVERFULL)
+    NETWORK_DISCONNECT_REJECT_SERVERFULL = 135,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_INVALIDRESERVATION)
+    NETWORK_DISCONNECT_REJECT_INVALIDRESERVATION = 136,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_FAILEDCHANNEL)
+    NETWORK_DISCONNECT_REJECT_FAILEDCHANNEL = 137,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_CONNECT_FROM_LOBBY)
+    NETWORK_DISCONNECT_REJECT_CONNECT_FROM_LOBBY = 138,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_RESERVED_FOR_LOBBY)
+    NETWORK_DISCONNECT_REJECT_RESERVED_FOR_LOBBY = 139,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_INVALIDKEYLENGTH)
+    NETWORK_DISCONNECT_REJECT_INVALIDKEYLENGTH = 140,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_OLDPROTOCOL)
+    NETWORK_DISCONNECT_REJECT_OLDPROTOCOL = 141,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_NEWPROTOCOL)
+    NETWORK_DISCONNECT_REJECT_NEWPROTOCOL = 142,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_INVALIDCONNECTION)
+    NETWORK_DISCONNECT_REJECT_INVALIDCONNECTION = 143,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_INVALIDCERTLEN)
+    NETWORK_DISCONNECT_REJECT_INVALIDCERTLEN = 144,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_INVALIDSTEAMCERTLEN)
+    NETWORK_DISCONNECT_REJECT_INVALIDSTEAMCERTLEN = 145,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_STEAM)
+    NETWORK_DISCONNECT_REJECT_STEAM = 146,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_SERVERAUTHDISABLED)
+    NETWORK_DISCONNECT_REJECT_SERVERAUTHDISABLED = 147,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_SERVERCDKEYAUTHINVALID)
+    NETWORK_DISCONNECT_REJECT_SERVERCDKEYAUTHINVALID = 148,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_REJECT_BANNED)
+    NETWORK_DISCONNECT_REJECT_BANNED = 149,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_KICKED_TEAMKILLING)
+    NETWORK_DISCONNECT_KICKED_TEAMKILLING = 150,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_KICKED_TK_START)
+    NETWORK_DISCONNECT_KICKED_TK_START = 151,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_KICKED_UNTRUSTEDACCOUNT)
+    NETWORK_DISCONNECT_KICKED_UNTRUSTEDACCOUNT = 152,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_KICKED_CONVICTEDACCOUNT)
+    NETWORK_DISCONNECT_KICKED_CONVICTEDACCOUNT = 153,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_KICKED_COMPETITIVECOOLDOWN)
+    NETWORK_DISCONNECT_KICKED_COMPETITIVECOOLDOWN = 154,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_KICKED_TEAMHURTING)
+    NETWORK_DISCONNECT_KICKED_TEAMHURTING = 155,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_KICKED_HOSTAGEKILLING)
+    NETWORK_DISCONNECT_KICKED_HOSTAGEKILLING = 156,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_KICKED_VOTEDOFF)
+    NETWORK_DISCONNECT_KICKED_VOTEDOFF = 157,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_KICKED_IDLE)
+    NETWORK_DISCONNECT_KICKED_IDLE = 158,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_KICKED_SUICIDE)
+    NETWORK_DISCONNECT_KICKED_SUICIDE = 159,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_KICKED_NOSTEAMLOGIN)
+    NETWORK_DISCONNECT_KICKED_NOSTEAMLOGIN = 160,
+    // @@protoc_insertion_point(enum_value:ENetworkDisconnectionReason.NETWORK_DISCONNECT_KICKED_NOSTEAMTICKET)
+    NETWORK_DISCONNECT_KICKED_NOSTEAMTICKET = 161,
+}
+
+impl ::steam_vent_proto_common::protobuf::Enum for ENetworkDisconnectionReason {
+    const NAME: &'static str = "ENetworkDisconnectionReason";
+
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<ENetworkDisconnectionReason> {
+        match value {
+            0 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_INVALID),
+            1 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SHUTDOWN),
+            2 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_DISCONNECT_BY_USER),
+            3 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_DISCONNECT_BY_SERVER),
+            4 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOST),
+            5 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_OVERFLOW),
+            6 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_BANNED),
+            7 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_INUSE),
+            8 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_TICKET),
+            9 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_LOGON),
+            10 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_AUTHCANCELLED),
+            11 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_AUTHALREADYUSED),
+            12 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_AUTHINVALID),
+            13 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_VACBANSTATE),
+            14 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_LOGGED_IN_ELSEWHERE),
+            15 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_VAC_CHECK_TIMEDOUT),
+            16 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_DROPPED),
+            17 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_OWNERSHIP),
+            18 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SERVERINFO_OVERFLOW),
+            19 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_TICKMSG_OVERFLOW),
+            20 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STRINGTABLEMSG_OVERFLOW),
+            21 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_DELTAENTMSG_OVERFLOW),
+            22 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_TEMPENTMSG_OVERFLOW),
+            23 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SOUNDSMSG_OVERFLOW),
+            24 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SNAPSHOTOVERFLOW),
+            25 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SNAPSHOTERROR),
+            26 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_RELIABLEOVERFLOW),
+            27 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_BADDELTATICK),
+            28 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_NOMORESPLITS),
+            29 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_TIMEDOUT),
+            30 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_DISCONNECTED),
+            31 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LEAVINGSPLIT),
+            32 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_DIFFERENTCLASSTABLES),
+            33 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_BADRELAYPASSWORD),
+            34 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_BADSPECTATORPASSWORD),
+            35 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_HLTVRESTRICTED),
+            36 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_NOSPECTATORS),
+            37 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_HLTVUNAVAILABLE),
+            38 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_HLTVSTOP),
+            39 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED),
+            40 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_BANADDED),
+            41 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKBANADDED),
+            42 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_HLTVDIRECT),
+            43 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_PURESERVER_CLIENTEXTRA),
+            44 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_PURESERVER_MISMATCH),
+            45 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_USERCMD),
+            46 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECTED_BY_GAME),
+            47 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_MESSAGE_PARSE_ERROR),
+            48 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_INVALID_MESSAGE_ERROR),
+            49 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_BAD_SERVER_PASSWORD),
+            50 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_DIRECT_CONNECT_RESERVATION),
+            51 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_CONNECTION_FAILURE),
+            52 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_NO_PEER_GROUP_HANDLERS),
+            53 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_RECONNECTION),
+            54 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOOPSHUTDOWN),
+            55 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOOPDEACTIVATE),
+            56 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_HOST_ENDGAME),
+            57 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOOP_LEVELLOAD_ACTIVATE),
+            58 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_CREATE_SERVER_FAILED),
+            59 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_EXITING),
+            60 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REQUEST_HOSTSTATE_IDLE),
+            61 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REQUEST_HOSTSTATE_HLTVRELAY),
+            62 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_CLIENT_CONSISTENCY_FAIL),
+            63 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_CLIENT_UNABLE_TO_CRC_MAP),
+            64 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_CLIENT_NO_MAP),
+            65 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_CLIENT_DIFFERENT_MAP),
+            66 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SERVER_REQUIRES_STEAM),
+            67 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_DENY_MISC),
+            68 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_DENY_BAD_ANTI_CHEAT),
+            69 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SERVER_SHUTDOWN),
+            71 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REPLAY_INCOMPATIBLE),
+            72 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_CONNECT_REQUEST_TIMEDOUT),
+            73 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SERVER_INCOMPATIBLE),
+            74 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOCALPROBLEM_MANYRELAYS),
+            75 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOCALPROBLEM_HOSTEDSERVERPRIMARYRELAY),
+            76 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOCALPROBLEM_NETWORKCONFIG),
+            77 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOCALPROBLEM_OTHER),
+            79 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REMOTE_TIMEOUT),
+            80 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REMOTE_TIMEOUT_CONNECTING),
+            81 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REMOTE_OTHER),
+            82 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REMOTE_BADCRYPT),
+            83 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REMOTE_CERTNOTTRUSTED),
+            84 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_UNUSUAL),
+            85 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_INTERNAL_ERROR),
+            128 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_BADCHALLENGE),
+            129 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_NOLOBBY),
+            130 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_BACKGROUND_MAP),
+            131 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_SINGLE_PLAYER),
+            132 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_HIDDEN_GAME),
+            133 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_LANRESTRICT),
+            134 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_BADPASSWORD),
+            135 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_SERVERFULL),
+            136 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_INVALIDRESERVATION),
+            137 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_FAILEDCHANNEL),
+            138 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_CONNECT_FROM_LOBBY),
+            139 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_RESERVED_FOR_LOBBY),
+            140 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_INVALIDKEYLENGTH),
+            141 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_OLDPROTOCOL),
+            142 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_NEWPROTOCOL),
+            143 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_INVALIDCONNECTION),
+            144 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_INVALIDCERTLEN),
+            145 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_INVALIDSTEAMCERTLEN),
+            146 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_STEAM),
+            147 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_SERVERAUTHDISABLED),
+            148 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_SERVERCDKEYAUTHINVALID),
+            149 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_BANNED),
+            150 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_TEAMKILLING),
+            151 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_TK_START),
+            152 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_UNTRUSTEDACCOUNT),
+            153 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_CONVICTEDACCOUNT),
+            154 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_COMPETITIVECOOLDOWN),
+            155 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_TEAMHURTING),
+            156 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_HOSTAGEKILLING),
+            157 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_VOTEDOFF),
+            158 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_IDLE),
+            159 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_SUICIDE),
+            160 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_NOSTEAMLOGIN),
+            161 => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_NOSTEAMTICKET),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn from_str(str: &str) -> ::std::option::Option<ENetworkDisconnectionReason> {
+        match str {
+            "NETWORK_DISCONNECT_INVALID" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_INVALID),
+            "NETWORK_DISCONNECT_SHUTDOWN" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SHUTDOWN),
+            "NETWORK_DISCONNECT_DISCONNECT_BY_USER" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_DISCONNECT_BY_USER),
+            "NETWORK_DISCONNECT_DISCONNECT_BY_SERVER" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_DISCONNECT_BY_SERVER),
+            "NETWORK_DISCONNECT_LOST" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOST),
+            "NETWORK_DISCONNECT_OVERFLOW" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_OVERFLOW),
+            "NETWORK_DISCONNECT_STEAM_BANNED" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_BANNED),
+            "NETWORK_DISCONNECT_STEAM_INUSE" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_INUSE),
+            "NETWORK_DISCONNECT_STEAM_TICKET" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_TICKET),
+            "NETWORK_DISCONNECT_STEAM_LOGON" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_LOGON),
+            "NETWORK_DISCONNECT_STEAM_AUTHCANCELLED" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_AUTHCANCELLED),
+            "NETWORK_DISCONNECT_STEAM_AUTHALREADYUSED" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_AUTHALREADYUSED),
+            "NETWORK_DISCONNECT_STEAM_AUTHINVALID" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_AUTHINVALID),
+            "NETWORK_DISCONNECT_STEAM_VACBANSTATE" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_VACBANSTATE),
+            "NETWORK_DISCONNECT_STEAM_LOGGED_IN_ELSEWHERE" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_LOGGED_IN_ELSEWHERE),
+            "NETWORK_DISCONNECT_STEAM_VAC_CHECK_TIMEDOUT" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_VAC_CHECK_TIMEDOUT),
+            "NETWORK_DISCONNECT_STEAM_DROPPED" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_DROPPED),
+            "NETWORK_DISCONNECT_STEAM_OWNERSHIP" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_OWNERSHIP),
+            "NETWORK_DISCONNECT_SERVERINFO_OVERFLOW" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SERVERINFO_OVERFLOW),
+            "NETWORK_DISCONNECT_TICKMSG_OVERFLOW" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_TICKMSG_OVERFLOW),
+            "NETWORK_DISCONNECT_STRINGTABLEMSG_OVERFLOW" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STRINGTABLEMSG_OVERFLOW),
+            "NETWORK_DISCONNECT_DELTAENTMSG_OVERFLOW" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_DELTAENTMSG_OVERFLOW),
+            "NETWORK_DISCONNECT_TEMPENTMSG_OVERFLOW" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_TEMPENTMSG_OVERFLOW),
+            "NETWORK_DISCONNECT_SOUNDSMSG_OVERFLOW" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SOUNDSMSG_OVERFLOW),
+            "NETWORK_DISCONNECT_SNAPSHOTOVERFLOW" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SNAPSHOTOVERFLOW),
+            "NETWORK_DISCONNECT_SNAPSHOTERROR" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SNAPSHOTERROR),
+            "NETWORK_DISCONNECT_RELIABLEOVERFLOW" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_RELIABLEOVERFLOW),
+            "NETWORK_DISCONNECT_BADDELTATICK" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_BADDELTATICK),
+            "NETWORK_DISCONNECT_NOMORESPLITS" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_NOMORESPLITS),
+            "NETWORK_DISCONNECT_TIMEDOUT" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_TIMEDOUT),
+            "NETWORK_DISCONNECT_DISCONNECTED" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_DISCONNECTED),
+            "NETWORK_DISCONNECT_LEAVINGSPLIT" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LEAVINGSPLIT),
+            "NETWORK_DISCONNECT_DIFFERENTCLASSTABLES" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_DIFFERENTCLASSTABLES),
+            "NETWORK_DISCONNECT_BADRELAYPASSWORD" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_BADRELAYPASSWORD),
+            "NETWORK_DISCONNECT_BADSPECTATORPASSWORD" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_BADSPECTATORPASSWORD),
+            "NETWORK_DISCONNECT_HLTVRESTRICTED" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_HLTVRESTRICTED),
+            "NETWORK_DISCONNECT_NOSPECTATORS" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_NOSPECTATORS),
+            "NETWORK_DISCONNECT_HLTVUNAVAILABLE" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_HLTVUNAVAILABLE),
+            "NETWORK_DISCONNECT_HLTVSTOP" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_HLTVSTOP),
+            "NETWORK_DISCONNECT_KICKED" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED),
+            "NETWORK_DISCONNECT_BANADDED" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_BANADDED),
+            "NETWORK_DISCONNECT_KICKBANADDED" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKBANADDED),
+            "NETWORK_DISCONNECT_HLTVDIRECT" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_HLTVDIRECT),
+            "NETWORK_DISCONNECT_PURESERVER_CLIENTEXTRA" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_PURESERVER_CLIENTEXTRA),
+            "NETWORK_DISCONNECT_PURESERVER_MISMATCH" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_PURESERVER_MISMATCH),
+            "NETWORK_DISCONNECT_USERCMD" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_USERCMD),
+            "NETWORK_DISCONNECT_REJECTED_BY_GAME" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECTED_BY_GAME),
+            "NETWORK_DISCONNECT_MESSAGE_PARSE_ERROR" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_MESSAGE_PARSE_ERROR),
+            "NETWORK_DISCONNECT_INVALID_MESSAGE_ERROR" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_INVALID_MESSAGE_ERROR),
+            "NETWORK_DISCONNECT_BAD_SERVER_PASSWORD" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_BAD_SERVER_PASSWORD),
+            "NETWORK_DISCONNECT_DIRECT_CONNECT_RESERVATION" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_DIRECT_CONNECT_RESERVATION),
+            "NETWORK_DISCONNECT_CONNECTION_FAILURE" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_CONNECTION_FAILURE),
+            "NETWORK_DISCONNECT_NO_PEER_GROUP_HANDLERS" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_NO_PEER_GROUP_HANDLERS),
+            "NETWORK_DISCONNECT_RECONNECTION" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_RECONNECTION),
+            "NETWORK_DISCONNECT_LOOPSHUTDOWN" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOOPSHUTDOWN),
+            "NETWORK_DISCONNECT_LOOPDEACTIVATE" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOOPDEACTIVATE),
+            "NETWORK_DISCONNECT_HOST_ENDGAME" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_HOST_ENDGAME),
+            "NETWORK_DISCONNECT_LOOP_LEVELLOAD_ACTIVATE" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOOP_LEVELLOAD_ACTIVATE),
+            "NETWORK_DISCONNECT_CREATE_SERVER_FAILED" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_CREATE_SERVER_FAILED),
+            "NETWORK_DISCONNECT_EXITING" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_EXITING),
+            "NETWORK_DISCONNECT_REQUEST_HOSTSTATE_IDLE" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REQUEST_HOSTSTATE_IDLE),
+            "NETWORK_DISCONNECT_REQUEST_HOSTSTATE_HLTVRELAY" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REQUEST_HOSTSTATE_HLTVRELAY),
+            "NETWORK_DISCONNECT_CLIENT_CONSISTENCY_FAIL" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_CLIENT_CONSISTENCY_FAIL),
+            "NETWORK_DISCONNECT_CLIENT_UNABLE_TO_CRC_MAP" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_CLIENT_UNABLE_TO_CRC_MAP),
+            "NETWORK_DISCONNECT_CLIENT_NO_MAP" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_CLIENT_NO_MAP),
+            "NETWORK_DISCONNECT_CLIENT_DIFFERENT_MAP" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_CLIENT_DIFFERENT_MAP),
+            "NETWORK_DISCONNECT_SERVER_REQUIRES_STEAM" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SERVER_REQUIRES_STEAM),
+            "NETWORK_DISCONNECT_STEAM_DENY_MISC" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_DENY_MISC),
+            "NETWORK_DISCONNECT_STEAM_DENY_BAD_ANTI_CHEAT" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_DENY_BAD_ANTI_CHEAT),
+            "NETWORK_DISCONNECT_SERVER_SHUTDOWN" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SERVER_SHUTDOWN),
+            "NETWORK_DISCONNECT_REPLAY_INCOMPATIBLE" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REPLAY_INCOMPATIBLE),
+            "NETWORK_DISCONNECT_CONNECT_REQUEST_TIMEDOUT" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_CONNECT_REQUEST_TIMEDOUT),
+            "NETWORK_DISCONNECT_SERVER_INCOMPATIBLE" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_SERVER_INCOMPATIBLE),
+            "NETWORK_DISCONNECT_LOCALPROBLEM_MANYRELAYS" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOCALPROBLEM_MANYRELAYS),
+            "NETWORK_DISCONNECT_LOCALPROBLEM_HOSTEDSERVERPRIMARYRELAY" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOCALPROBLEM_HOSTEDSERVERPRIMARYRELAY),
+            "NETWORK_DISCONNECT_LOCALPROBLEM_NETWORKCONFIG" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOCALPROBLEM_NETWORKCONFIG),
+            "NETWORK_DISCONNECT_LOCALPROBLEM_OTHER" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOCALPROBLEM_OTHER),
+            "NETWORK_DISCONNECT_REMOTE_TIMEOUT" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REMOTE_TIMEOUT),
+            "NETWORK_DISCONNECT_REMOTE_TIMEOUT_CONNECTING" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REMOTE_TIMEOUT_CONNECTING),
+            "NETWORK_DISCONNECT_REMOTE_OTHER" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REMOTE_OTHER),
+            "NETWORK_DISCONNECT_REMOTE_BADCRYPT" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REMOTE_BADCRYPT),
+            "NETWORK_DISCONNECT_REMOTE_CERTNOTTRUSTED" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REMOTE_CERTNOTTRUSTED),
+            "NETWORK_DISCONNECT_UNUSUAL" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_UNUSUAL),
+            "NETWORK_DISCONNECT_INTERNAL_ERROR" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_INTERNAL_ERROR),
+            "NETWORK_DISCONNECT_REJECT_BADCHALLENGE" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_BADCHALLENGE),
+            "NETWORK_DISCONNECT_REJECT_NOLOBBY" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_NOLOBBY),
+            "NETWORK_DISCONNECT_REJECT_BACKGROUND_MAP" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_BACKGROUND_MAP),
+            "NETWORK_DISCONNECT_REJECT_SINGLE_PLAYER" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_SINGLE_PLAYER),
+            "NETWORK_DISCONNECT_REJECT_HIDDEN_GAME" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_HIDDEN_GAME),
+            "NETWORK_DISCONNECT_REJECT_LANRESTRICT" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_LANRESTRICT),
+            "NETWORK_DISCONNECT_REJECT_BADPASSWORD" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_BADPASSWORD),
+            "NETWORK_DISCONNECT_REJECT_SERVERFULL" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_SERVERFULL),
+            "NETWORK_DISCONNECT_REJECT_INVALIDRESERVATION" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_INVALIDRESERVATION),
+            "NETWORK_DISCONNECT_REJECT_FAILEDCHANNEL" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_FAILEDCHANNEL),
+            "NETWORK_DISCONNECT_REJECT_CONNECT_FROM_LOBBY" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_CONNECT_FROM_LOBBY),
+            "NETWORK_DISCONNECT_REJECT_RESERVED_FOR_LOBBY" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_RESERVED_FOR_LOBBY),
+            "NETWORK_DISCONNECT_REJECT_INVALIDKEYLENGTH" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_INVALIDKEYLENGTH),
+            "NETWORK_DISCONNECT_REJECT_OLDPROTOCOL" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_OLDPROTOCOL),
+            "NETWORK_DISCONNECT_REJECT_NEWPROTOCOL" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_NEWPROTOCOL),
+            "NETWORK_DISCONNECT_REJECT_INVALIDCONNECTION" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_INVALIDCONNECTION),
+            "NETWORK_DISCONNECT_REJECT_INVALIDCERTLEN" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_INVALIDCERTLEN),
+            "NETWORK_DISCONNECT_REJECT_INVALIDSTEAMCERTLEN" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_INVALIDSTEAMCERTLEN),
+            "NETWORK_DISCONNECT_REJECT_STEAM" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_STEAM),
+            "NETWORK_DISCONNECT_REJECT_SERVERAUTHDISABLED" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_SERVERAUTHDISABLED),
+            "NETWORK_DISCONNECT_REJECT_SERVERCDKEYAUTHINVALID" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_SERVERCDKEYAUTHINVALID),
+            "NETWORK_DISCONNECT_REJECT_BANNED" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_BANNED),
+            "NETWORK_DISCONNECT_KICKED_TEAMKILLING" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_TEAMKILLING),
+            "NETWORK_DISCONNECT_KICKED_TK_START" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_TK_START),
+            "NETWORK_DISCONNECT_KICKED_UNTRUSTEDACCOUNT" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_UNTRUSTEDACCOUNT),
+            "NETWORK_DISCONNECT_KICKED_CONVICTEDACCOUNT" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_CONVICTEDACCOUNT),
+            "NETWORK_DISCONNECT_KICKED_COMPETITIVECOOLDOWN" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_COMPETITIVECOOLDOWN),
+            "NETWORK_DISCONNECT_KICKED_TEAMHURTING" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_TEAMHURTING),
+            "NETWORK_DISCONNECT_KICKED_HOSTAGEKILLING" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_HOSTAGEKILLING),
+            "NETWORK_DISCONNECT_KICKED_VOTEDOFF" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_VOTEDOFF),
+            "NETWORK_DISCONNECT_KICKED_IDLE" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_IDLE),
+            "NETWORK_DISCONNECT_KICKED_SUICIDE" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_SUICIDE),
+            "NETWORK_DISCONNECT_KICKED_NOSTEAMLOGIN" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_NOSTEAMLOGIN),
+            "NETWORK_DISCONNECT_KICKED_NOSTEAMTICKET" => ::std::option::Option::Some(ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_NOSTEAMTICKET),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    const VALUES: &'static [ENetworkDisconnectionReason] = &[
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_INVALID,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_SHUTDOWN,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_DISCONNECT_BY_USER,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_DISCONNECT_BY_SERVER,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOST,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_OVERFLOW,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_BANNED,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_INUSE,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_TICKET,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_LOGON,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_AUTHCANCELLED,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_AUTHALREADYUSED,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_AUTHINVALID,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_VACBANSTATE,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_LOGGED_IN_ELSEWHERE,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_VAC_CHECK_TIMEDOUT,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_DROPPED,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_OWNERSHIP,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_SERVERINFO_OVERFLOW,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_TICKMSG_OVERFLOW,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_STRINGTABLEMSG_OVERFLOW,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_DELTAENTMSG_OVERFLOW,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_TEMPENTMSG_OVERFLOW,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_SOUNDSMSG_OVERFLOW,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_SNAPSHOTOVERFLOW,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_SNAPSHOTERROR,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_RELIABLEOVERFLOW,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_BADDELTATICK,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_NOMORESPLITS,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_TIMEDOUT,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_DISCONNECTED,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_LEAVINGSPLIT,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_DIFFERENTCLASSTABLES,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_BADRELAYPASSWORD,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_BADSPECTATORPASSWORD,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_HLTVRESTRICTED,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_NOSPECTATORS,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_HLTVUNAVAILABLE,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_HLTVSTOP,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_BANADDED,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKBANADDED,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_HLTVDIRECT,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_PURESERVER_CLIENTEXTRA,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_PURESERVER_MISMATCH,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_USERCMD,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECTED_BY_GAME,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_MESSAGE_PARSE_ERROR,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_INVALID_MESSAGE_ERROR,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_BAD_SERVER_PASSWORD,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_DIRECT_CONNECT_RESERVATION,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_CONNECTION_FAILURE,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_NO_PEER_GROUP_HANDLERS,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_RECONNECTION,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOOPSHUTDOWN,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOOPDEACTIVATE,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_HOST_ENDGAME,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOOP_LEVELLOAD_ACTIVATE,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_CREATE_SERVER_FAILED,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_EXITING,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REQUEST_HOSTSTATE_IDLE,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REQUEST_HOSTSTATE_HLTVRELAY,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_CLIENT_CONSISTENCY_FAIL,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_CLIENT_UNABLE_TO_CRC_MAP,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_CLIENT_NO_MAP,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_CLIENT_DIFFERENT_MAP,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_SERVER_REQUIRES_STEAM,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_DENY_MISC,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_STEAM_DENY_BAD_ANTI_CHEAT,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_SERVER_SHUTDOWN,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REPLAY_INCOMPATIBLE,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_CONNECT_REQUEST_TIMEDOUT,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_SERVER_INCOMPATIBLE,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOCALPROBLEM_MANYRELAYS,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOCALPROBLEM_HOSTEDSERVERPRIMARYRELAY,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOCALPROBLEM_NETWORKCONFIG,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_LOCALPROBLEM_OTHER,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REMOTE_TIMEOUT,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REMOTE_TIMEOUT_CONNECTING,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REMOTE_OTHER,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REMOTE_BADCRYPT,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REMOTE_CERTNOTTRUSTED,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_UNUSUAL,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_INTERNAL_ERROR,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_BADCHALLENGE,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_NOLOBBY,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_BACKGROUND_MAP,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_SINGLE_PLAYER,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_HIDDEN_GAME,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_LANRESTRICT,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_BADPASSWORD,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_SERVERFULL,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_INVALIDRESERVATION,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_FAILEDCHANNEL,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_CONNECT_FROM_LOBBY,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_RESERVED_FOR_LOBBY,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_INVALIDKEYLENGTH,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_OLDPROTOCOL,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_NEWPROTOCOL,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_INVALIDCONNECTION,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_INVALIDCERTLEN,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_INVALIDSTEAMCERTLEN,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_STEAM,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_SERVERAUTHDISABLED,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_SERVERCDKEYAUTHINVALID,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_REJECT_BANNED,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_TEAMKILLING,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_TK_START,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_UNTRUSTEDACCOUNT,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_CONVICTEDACCOUNT,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_COMPETITIVECOOLDOWN,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_TEAMHURTING,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_HOSTAGEKILLING,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_VOTEDOFF,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_IDLE,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_SUICIDE,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_NOSTEAMLOGIN,
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_KICKED_NOSTEAMTICKET,
+    ];
+}
+
+impl ::std::default::Default for ENetworkDisconnectionReason {
+    fn default() -> Self {
+        ENetworkDisconnectionReason::NETWORK_DISCONNECT_INVALID
+    }
+}
+
+
+// Extension generation with lite runtime is not supported
+
+
+const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;

src/generated/networksystem_protomessages.rs

@@ -0,0 +1,574 @@
+// 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 `networksystem_protomessages.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:NetMessageSplitscreenUserChanged)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct NetMessageSplitscreenUserChanged {
+    // message fields
+    // @@protoc_insertion_point(field:NetMessageSplitscreenUserChanged.slot)
+    pub slot: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:NetMessageSplitscreenUserChanged.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a NetMessageSplitscreenUserChanged {
+    fn default() -> &'a NetMessageSplitscreenUserChanged {
+        <NetMessageSplitscreenUserChanged as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl NetMessageSplitscreenUserChanged {
+    pub fn new() -> NetMessageSplitscreenUserChanged {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 slot = 1;
+
+    pub fn slot(&self) -> u32 {
+        self.slot.unwrap_or(0)
+    }
+
+    pub fn clear_slot(&mut self) {
+        self.slot = ::std::option::Option::None;
+    }
+
+    pub fn has_slot(&self) -> bool {
+        self.slot.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_slot(&mut self, v: u32) {
+        self.slot = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for NetMessageSplitscreenUserChanged {
+    const NAME: &'static str = "NetMessageSplitscreenUserChanged";
+
+    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.slot = ::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.slot {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_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.slot {
+            os.write_uint32(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() -> NetMessageSplitscreenUserChanged {
+        NetMessageSplitscreenUserChanged::new()
+    }
+
+    fn clear(&mut self) {
+        self.slot = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static NetMessageSplitscreenUserChanged {
+        static instance: NetMessageSplitscreenUserChanged = NetMessageSplitscreenUserChanged {
+            slot: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:NetMessageConnectionClosed)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct NetMessageConnectionClosed {
+    // message fields
+    // @@protoc_insertion_point(field:NetMessageConnectionClosed.reason)
+    pub reason: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:NetMessageConnectionClosed.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a NetMessageConnectionClosed {
+    fn default() -> &'a NetMessageConnectionClosed {
+        <NetMessageConnectionClosed as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl NetMessageConnectionClosed {
+    pub fn new() -> NetMessageConnectionClosed {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 reason = 1;
+
+    pub fn reason(&self) -> u32 {
+        self.reason.unwrap_or(0)
+    }
+
+    pub fn clear_reason(&mut self) {
+        self.reason = ::std::option::Option::None;
+    }
+
+    pub fn has_reason(&self) -> bool {
+        self.reason.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_reason(&mut self, v: u32) {
+        self.reason = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for NetMessageConnectionClosed {
+    const NAME: &'static str = "NetMessageConnectionClosed";
+
+    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.reason = ::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.reason {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_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.reason {
+            os.write_uint32(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() -> NetMessageConnectionClosed {
+        NetMessageConnectionClosed::new()
+    }
+
+    fn clear(&mut self) {
+        self.reason = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static NetMessageConnectionClosed {
+        static instance: NetMessageConnectionClosed = NetMessageConnectionClosed {
+            reason: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:NetMessageConnectionCrashed)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct NetMessageConnectionCrashed {
+    // message fields
+    // @@protoc_insertion_point(field:NetMessageConnectionCrashed.reason)
+    pub reason: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:NetMessageConnectionCrashed.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a NetMessageConnectionCrashed {
+    fn default() -> &'a NetMessageConnectionCrashed {
+        <NetMessageConnectionCrashed as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl NetMessageConnectionCrashed {
+    pub fn new() -> NetMessageConnectionCrashed {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 reason = 1;
+
+    pub fn reason(&self) -> u32 {
+        self.reason.unwrap_or(0)
+    }
+
+    pub fn clear_reason(&mut self) {
+        self.reason = ::std::option::Option::None;
+    }
+
+    pub fn has_reason(&self) -> bool {
+        self.reason.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_reason(&mut self, v: u32) {
+        self.reason = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for NetMessageConnectionCrashed {
+    const NAME: &'static str = "NetMessageConnectionCrashed";
+
+    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.reason = ::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.reason {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_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.reason {
+            os.write_uint32(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() -> NetMessageConnectionCrashed {
+        NetMessageConnectionCrashed::new()
+    }
+
+    fn clear(&mut self) {
+        self.reason = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static NetMessageConnectionCrashed {
+        static instance: NetMessageConnectionCrashed = NetMessageConnectionCrashed {
+            reason: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:NetMessagePacketStart)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct NetMessagePacketStart {
+    // special fields
+    // @@protoc_insertion_point(special_field:NetMessagePacketStart.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a NetMessagePacketStart {
+    fn default() -> &'a NetMessagePacketStart {
+        <NetMessagePacketStart as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl NetMessagePacketStart {
+    pub fn new() -> NetMessagePacketStart {
+        ::std::default::Default::default()
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for NetMessagePacketStart {
+    const NAME: &'static str = "NetMessagePacketStart";
+
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        while let Some(tag) = is.read_raw_tag_or_eof()? {
+            match tag {
+                tag => {
+                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u64 {
+        let mut my_size = 0;
+        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> NetMessagePacketStart {
+        NetMessagePacketStart::new()
+    }
+
+    fn clear(&mut self) {
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static NetMessagePacketStart {
+        static instance: NetMessagePacketStart = NetMessagePacketStart {
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:NetMessagePacketEnd)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct NetMessagePacketEnd {
+    // special fields
+    // @@protoc_insertion_point(special_field:NetMessagePacketEnd.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a NetMessagePacketEnd {
+    fn default() -> &'a NetMessagePacketEnd {
+        <NetMessagePacketEnd as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl NetMessagePacketEnd {
+    pub fn new() -> NetMessagePacketEnd {
+        ::std::default::Default::default()
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for NetMessagePacketEnd {
+    const NAME: &'static str = "NetMessagePacketEnd";
+
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        while let Some(tag) = is.read_raw_tag_or_eof()? {
+            match tag {
+                tag => {
+                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u64 {
+        let mut my_size = 0;
+        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> NetMessagePacketEnd {
+        NetMessagePacketEnd::new()
+    }
+
+    fn clear(&mut self) {
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static NetMessagePacketEnd {
+        static instance: NetMessagePacketEnd = NetMessagePacketEnd {
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+
+const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;
+
+impl ::steam_vent_proto_common::RpcMessage for NetMessageSplitscreenUserChanged {
+    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 NetMessageConnectionClosed {
+    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 NetMessageConnectionCrashed {
+    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 NetMessagePacketStart {
+    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 NetMessagePacketEnd {
+    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
+    }
+}

src/generated/steammessages.rs

@@ -0,0 +1,915 @@
+// This file is generated by rust-protobuf 3.5.1. Do not edit
+// .proto file is parsed by pure
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(dead_code)]
+#![allow(missing_docs)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+#![allow(trivial_casts)]
+#![allow(unused_results)]
+#![allow(unused_mut)]
+
+//! Generated file from `steammessages.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:CMsgProtoBufHeader)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CMsgProtoBufHeader {
+    // message fields
+    // @@protoc_insertion_point(field:CMsgProtoBufHeader.client_steam_id)
+    pub client_steam_id: ::std::option::Option<u64>,
+    // @@protoc_insertion_point(field:CMsgProtoBufHeader.client_session_id)
+    pub client_session_id: ::std::option::Option<i32>,
+    // @@protoc_insertion_point(field:CMsgProtoBufHeader.source_app_id)
+    pub source_app_id: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CMsgProtoBufHeader.job_id_source)
+    pub job_id_source: ::std::option::Option<u64>,
+    // @@protoc_insertion_point(field:CMsgProtoBufHeader.job_id_target)
+    pub job_id_target: ::std::option::Option<u64>,
+    // @@protoc_insertion_point(field:CMsgProtoBufHeader.target_job_name)
+    pub target_job_name: ::std::option::Option<::std::string::String>,
+    // @@protoc_insertion_point(field:CMsgProtoBufHeader.eresult)
+    pub eresult: ::std::option::Option<i32>,
+    // @@protoc_insertion_point(field:CMsgProtoBufHeader.error_message)
+    pub error_message: ::std::option::Option<::std::string::String>,
+    // @@protoc_insertion_point(field:CMsgProtoBufHeader.ip)
+    pub ip: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CMsgProtoBufHeader.gc_msg_src)
+    pub gc_msg_src: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<GCProtoBufMsgSrc>>,
+    // @@protoc_insertion_point(field:CMsgProtoBufHeader.gc_dir_index_source)
+    pub gc_dir_index_source: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CMsgProtoBufHeader.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CMsgProtoBufHeader {
+    fn default() -> &'a CMsgProtoBufHeader {
+        <CMsgProtoBufHeader as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CMsgProtoBufHeader {
+    pub fn new() -> CMsgProtoBufHeader {
+        ::std::default::Default::default()
+    }
+
+    // optional fixed64 client_steam_id = 1;
+
+    pub fn client_steam_id(&self) -> u64 {
+        self.client_steam_id.unwrap_or(0)
+    }
+
+    pub fn clear_client_steam_id(&mut self) {
+        self.client_steam_id = ::std::option::Option::None;
+    }
+
+    pub fn has_client_steam_id(&self) -> bool {
+        self.client_steam_id.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_client_steam_id(&mut self, v: u64) {
+        self.client_steam_id = ::std::option::Option::Some(v);
+    }
+
+    // optional int32 client_session_id = 2;
+
+    pub fn client_session_id(&self) -> i32 {
+        self.client_session_id.unwrap_or(0)
+    }
+
+    pub fn clear_client_session_id(&mut self) {
+        self.client_session_id = ::std::option::Option::None;
+    }
+
+    pub fn has_client_session_id(&self) -> bool {
+        self.client_session_id.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_client_session_id(&mut self, v: i32) {
+        self.client_session_id = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 source_app_id = 3;
+
+    pub fn source_app_id(&self) -> u32 {
+        self.source_app_id.unwrap_or(0)
+    }
+
+    pub fn clear_source_app_id(&mut self) {
+        self.source_app_id = ::std::option::Option::None;
+    }
+
+    pub fn has_source_app_id(&self) -> bool {
+        self.source_app_id.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_source_app_id(&mut self, v: u32) {
+        self.source_app_id = ::std::option::Option::Some(v);
+    }
+
+    // optional fixed64 job_id_source = 10;
+
+    pub fn job_id_source(&self) -> u64 {
+        self.job_id_source.unwrap_or(18446744073709551615u64)
+    }
+
+    pub fn clear_job_id_source(&mut self) {
+        self.job_id_source = ::std::option::Option::None;
+    }
+
+    pub fn has_job_id_source(&self) -> bool {
+        self.job_id_source.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_job_id_source(&mut self, v: u64) {
+        self.job_id_source = ::std::option::Option::Some(v);
+    }
+
+    // optional fixed64 job_id_target = 11;
+
+    pub fn job_id_target(&self) -> u64 {
+        self.job_id_target.unwrap_or(18446744073709551615u64)
+    }
+
+    pub fn clear_job_id_target(&mut self) {
+        self.job_id_target = ::std::option::Option::None;
+    }
+
+    pub fn has_job_id_target(&self) -> bool {
+        self.job_id_target.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_job_id_target(&mut self, v: u64) {
+        self.job_id_target = ::std::option::Option::Some(v);
+    }
+
+    // optional string target_job_name = 12;
+
+    pub fn target_job_name(&self) -> &str {
+        match self.target_job_name.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_target_job_name(&mut self) {
+        self.target_job_name = ::std::option::Option::None;
+    }
+
+    pub fn has_target_job_name(&self) -> bool {
+        self.target_job_name.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_target_job_name(&mut self, v: ::std::string::String) {
+        self.target_job_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_target_job_name(&mut self) -> &mut ::std::string::String {
+        if self.target_job_name.is_none() {
+            self.target_job_name = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.target_job_name.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_target_job_name(&mut self) -> ::std::string::String {
+        self.target_job_name.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional int32 eresult = 13;
+
+    pub fn eresult(&self) -> i32 {
+        self.eresult.unwrap_or(2i32)
+    }
+
+    pub fn clear_eresult(&mut self) {
+        self.eresult = ::std::option::Option::None;
+    }
+
+    pub fn has_eresult(&self) -> bool {
+        self.eresult.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_eresult(&mut self, v: i32) {
+        self.eresult = ::std::option::Option::Some(v);
+    }
+
+    // optional string error_message = 14;
+
+    pub fn error_message(&self) -> &str {
+        match self.error_message.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_error_message(&mut self) {
+        self.error_message = ::std::option::Option::None;
+    }
+
+    pub fn has_error_message(&self) -> bool {
+        self.error_message.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_error_message(&mut self, v: ::std::string::String) {
+        self.error_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_error_message(&mut self) -> &mut ::std::string::String {
+        if self.error_message.is_none() {
+            self.error_message = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.error_message.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_error_message(&mut self) -> ::std::string::String {
+        self.error_message.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional uint32 ip = 15;
+
+    pub fn ip(&self) -> u32 {
+        self.ip.unwrap_or(0)
+    }
+
+    pub fn clear_ip(&mut self) {
+        self.ip = ::std::option::Option::None;
+    }
+
+    pub fn has_ip(&self) -> bool {
+        self.ip.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_ip(&mut self, v: u32) {
+        self.ip = ::std::option::Option::Some(v);
+    }
+
+    // optional .GCProtoBufMsgSrc gc_msg_src = 200;
+
+    pub fn gc_msg_src(&self) -> GCProtoBufMsgSrc {
+        match self.gc_msg_src {
+            Some(e) => e.enum_value_or(GCProtoBufMsgSrc::GCProtoBufMsgSrc_Unspecified),
+            None => GCProtoBufMsgSrc::GCProtoBufMsgSrc_Unspecified,
+        }
+    }
+
+    pub fn clear_gc_msg_src(&mut self) {
+        self.gc_msg_src = ::std::option::Option::None;
+    }
+
+    pub fn has_gc_msg_src(&self) -> bool {
+        self.gc_msg_src.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_gc_msg_src(&mut self, v: GCProtoBufMsgSrc) {
+        self.gc_msg_src = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
+    }
+
+    // optional uint32 gc_dir_index_source = 201;
+
+    pub fn gc_dir_index_source(&self) -> u32 {
+        self.gc_dir_index_source.unwrap_or(0)
+    }
+
+    pub fn clear_gc_dir_index_source(&mut self) {
+        self.gc_dir_index_source = ::std::option::Option::None;
+    }
+
+    pub fn has_gc_dir_index_source(&self) -> bool {
+        self.gc_dir_index_source.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_gc_dir_index_source(&mut self, v: u32) {
+        self.gc_dir_index_source = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CMsgProtoBufHeader {
+    const NAME: &'static str = "CMsgProtoBufHeader";
+
+    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.client_steam_id = ::std::option::Option::Some(is.read_fixed64()?);
+                },
+                16 => {
+                    self.client_session_id = ::std::option::Option::Some(is.read_int32()?);
+                },
+                24 => {
+                    self.source_app_id = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                81 => {
+                    self.job_id_source = ::std::option::Option::Some(is.read_fixed64()?);
+                },
+                89 => {
+                    self.job_id_target = ::std::option::Option::Some(is.read_fixed64()?);
+                },
+                98 => {
+                    self.target_job_name = ::std::option::Option::Some(is.read_string()?);
+                },
+                104 => {
+                    self.eresult = ::std::option::Option::Some(is.read_int32()?);
+                },
+                114 => {
+                    self.error_message = ::std::option::Option::Some(is.read_string()?);
+                },
+                120 => {
+                    self.ip = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                1600 => {
+                    self.gc_msg_src = ::std::option::Option::Some(is.read_enum_or_unknown()?);
+                },
+                1608 => {
+                    self.gc_dir_index_source = ::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.client_steam_id {
+            my_size += 1 + 8;
+        }
+        if let Some(v) = self.client_session_id {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
+        }
+        if let Some(v) = self.source_app_id {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
+        }
+        if let Some(v) = self.job_id_source {
+            my_size += 1 + 8;
+        }
+        if let Some(v) = self.job_id_target {
+            my_size += 1 + 8;
+        }
+        if let Some(v) = self.target_job_name.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(12, &v);
+        }
+        if let Some(v) = self.eresult {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(13, v);
+        }
+        if let Some(v) = self.error_message.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(14, &v);
+        }
+        if let Some(v) = self.ip {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(15, v);
+        }
+        if let Some(v) = self.gc_msg_src {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(200, v.value());
+        }
+        if let Some(v) = self.gc_dir_index_source {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(201, 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_steam_id {
+            os.write_fixed64(1, v)?;
+        }
+        if let Some(v) = self.client_session_id {
+            os.write_int32(2, v)?;
+        }
+        if let Some(v) = self.source_app_id {
+            os.write_uint32(3, v)?;
+        }
+        if let Some(v) = self.job_id_source {
+            os.write_fixed64(10, v)?;
+        }
+        if let Some(v) = self.job_id_target {
+            os.write_fixed64(11, v)?;
+        }
+        if let Some(v) = self.target_job_name.as_ref() {
+            os.write_string(12, v)?;
+        }
+        if let Some(v) = self.eresult {
+            os.write_int32(13, v)?;
+        }
+        if let Some(v) = self.error_message.as_ref() {
+            os.write_string(14, v)?;
+        }
+        if let Some(v) = self.ip {
+            os.write_uint32(15, v)?;
+        }
+        if let Some(v) = self.gc_msg_src {
+            os.write_enum(200, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
+        }
+        if let Some(v) = self.gc_dir_index_source {
+            os.write_uint32(201, 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() -> CMsgProtoBufHeader {
+        CMsgProtoBufHeader::new()
+    }
+
+    fn clear(&mut self) {
+        self.client_steam_id = ::std::option::Option::None;
+        self.client_session_id = ::std::option::Option::None;
+        self.source_app_id = ::std::option::Option::None;
+        self.job_id_source = ::std::option::Option::None;
+        self.job_id_target = ::std::option::Option::None;
+        self.target_job_name = ::std::option::Option::None;
+        self.eresult = ::std::option::Option::None;
+        self.error_message = ::std::option::Option::None;
+        self.ip = ::std::option::Option::None;
+        self.gc_msg_src = ::std::option::Option::None;
+        self.gc_dir_index_source = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CMsgProtoBufHeader {
+        static instance: CMsgProtoBufHeader = CMsgProtoBufHeader {
+            client_steam_id: ::std::option::Option::None,
+            client_session_id: ::std::option::Option::None,
+            source_app_id: ::std::option::Option::None,
+            job_id_source: ::std::option::Option::None,
+            job_id_target: ::std::option::Option::None,
+            target_job_name: ::std::option::Option::None,
+            eresult: ::std::option::Option::None,
+            error_message: ::std::option::Option::None,
+            ip: ::std::option::Option::None,
+            gc_msg_src: ::std::option::Option::None,
+            gc_dir_index_source: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CChinaAgreementSessions_StartAgreementSessionInGame_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CChinaAgreementSessions_StartAgreementSessionInGame_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CChinaAgreementSessions_StartAgreementSessionInGame_Request.appid)
+    pub appid: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CChinaAgreementSessions_StartAgreementSessionInGame_Request.steamid)
+    pub steamid: ::std::option::Option<u64>,
+    // @@protoc_insertion_point(field:CChinaAgreementSessions_StartAgreementSessionInGame_Request.client_ipaddress)
+    pub client_ipaddress: ::std::option::Option<::std::string::String>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CChinaAgreementSessions_StartAgreementSessionInGame_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CChinaAgreementSessions_StartAgreementSessionInGame_Request {
+    fn default() -> &'a CChinaAgreementSessions_StartAgreementSessionInGame_Request {
+        <CChinaAgreementSessions_StartAgreementSessionInGame_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CChinaAgreementSessions_StartAgreementSessionInGame_Request {
+    pub fn new() -> CChinaAgreementSessions_StartAgreementSessionInGame_Request {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 appid = 1;
+
+    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 fixed64 steamid = 2;
+
+    pub fn steamid(&self) -> u64 {
+        self.steamid.unwrap_or(0)
+    }
+
+    pub fn clear_steamid(&mut self) {
+        self.steamid = ::std::option::Option::None;
+    }
+
+    pub fn has_steamid(&self) -> bool {
+        self.steamid.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_steamid(&mut self, v: u64) {
+        self.steamid = ::std::option::Option::Some(v);
+    }
+
+    // optional string client_ipaddress = 3;
+
+    pub fn client_ipaddress(&self) -> &str {
+        match self.client_ipaddress.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_client_ipaddress(&mut self) {
+        self.client_ipaddress = ::std::option::Option::None;
+    }
+
+    pub fn has_client_ipaddress(&self) -> bool {
+        self.client_ipaddress.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_client_ipaddress(&mut self, v: ::std::string::String) {
+        self.client_ipaddress = ::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_ipaddress(&mut self) -> &mut ::std::string::String {
+        if self.client_ipaddress.is_none() {
+            self.client_ipaddress = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.client_ipaddress.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_client_ipaddress(&mut self) -> ::std::string::String {
+        self.client_ipaddress.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CChinaAgreementSessions_StartAgreementSessionInGame_Request {
+    const NAME: &'static str = "CChinaAgreementSessions_StartAgreementSessionInGame_Request";
+
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        while let Some(tag) = is.read_raw_tag_or_eof()? {
+            match tag {
+                8 => {
+                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                17 => {
+                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
+                },
+                26 => {
+                    self.client_ipaddress = ::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.appid {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.steamid {
+            my_size += 1 + 8;
+        }
+        if let Some(v) = self.client_ipaddress.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.appid {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.steamid {
+            os.write_fixed64(2, v)?;
+        }
+        if let Some(v) = self.client_ipaddress.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() -> CChinaAgreementSessions_StartAgreementSessionInGame_Request {
+        CChinaAgreementSessions_StartAgreementSessionInGame_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.appid = ::std::option::Option::None;
+        self.steamid = ::std::option::Option::None;
+        self.client_ipaddress = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CChinaAgreementSessions_StartAgreementSessionInGame_Request {
+        static instance: CChinaAgreementSessions_StartAgreementSessionInGame_Request = CChinaAgreementSessions_StartAgreementSessionInGame_Request {
+            appid: ::std::option::Option::None,
+            steamid: ::std::option::Option::None,
+            client_ipaddress: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CChinaAgreementSessions_StartAgreementSessionInGame_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CChinaAgreementSessions_StartAgreementSessionInGame_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CChinaAgreementSessions_StartAgreementSessionInGame_Response.agreement_url)
+    pub agreement_url: ::std::option::Option<::std::string::String>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CChinaAgreementSessions_StartAgreementSessionInGame_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CChinaAgreementSessions_StartAgreementSessionInGame_Response {
+    fn default() -> &'a CChinaAgreementSessions_StartAgreementSessionInGame_Response {
+        <CChinaAgreementSessions_StartAgreementSessionInGame_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CChinaAgreementSessions_StartAgreementSessionInGame_Response {
+    pub fn new() -> CChinaAgreementSessions_StartAgreementSessionInGame_Response {
+        ::std::default::Default::default()
+    }
+
+    // optional string agreement_url = 1;
+
+    pub fn agreement_url(&self) -> &str {
+        match self.agreement_url.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_agreement_url(&mut self) {
+        self.agreement_url = ::std::option::Option::None;
+    }
+
+    pub fn has_agreement_url(&self) -> bool {
+        self.agreement_url.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_agreement_url(&mut self, v: ::std::string::String) {
+        self.agreement_url = ::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_agreement_url(&mut self) -> &mut ::std::string::String {
+        if self.agreement_url.is_none() {
+            self.agreement_url = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.agreement_url.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_agreement_url(&mut self) -> ::std::string::String {
+        self.agreement_url.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CChinaAgreementSessions_StartAgreementSessionInGame_Response {
+    const NAME: &'static str = "CChinaAgreementSessions_StartAgreementSessionInGame_Response";
+
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        while let Some(tag) = is.read_raw_tag_or_eof()? {
+            match tag {
+                10 => {
+                    self.agreement_url = ::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.agreement_url.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.agreement_url.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() -> CChinaAgreementSessions_StartAgreementSessionInGame_Response {
+        CChinaAgreementSessions_StartAgreementSessionInGame_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.agreement_url = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CChinaAgreementSessions_StartAgreementSessionInGame_Response {
+        static instance: CChinaAgreementSessions_StartAgreementSessionInGame_Response = CChinaAgreementSessions_StartAgreementSessionInGame_Response {
+            agreement_url: ::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:GCProtoBufMsgSrc)
+pub enum GCProtoBufMsgSrc {
+    // @@protoc_insertion_point(enum_value:GCProtoBufMsgSrc.GCProtoBufMsgSrc_Unspecified)
+    GCProtoBufMsgSrc_Unspecified = 0,
+    // @@protoc_insertion_point(enum_value:GCProtoBufMsgSrc.GCProtoBufMsgSrc_FromSystem)
+    GCProtoBufMsgSrc_FromSystem = 1,
+    // @@protoc_insertion_point(enum_value:GCProtoBufMsgSrc.GCProtoBufMsgSrc_FromSteamID)
+    GCProtoBufMsgSrc_FromSteamID = 2,
+    // @@protoc_insertion_point(enum_value:GCProtoBufMsgSrc.GCProtoBufMsgSrc_FromGC)
+    GCProtoBufMsgSrc_FromGC = 3,
+    // @@protoc_insertion_point(enum_value:GCProtoBufMsgSrc.GCProtoBufMsgSrc_ReplySystem)
+    GCProtoBufMsgSrc_ReplySystem = 4,
+}
+
+impl ::steam_vent_proto_common::protobuf::Enum for GCProtoBufMsgSrc {
+    const NAME: &'static str = "GCProtoBufMsgSrc";
+
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<GCProtoBufMsgSrc> {
+        match value {
+            0 => ::std::option::Option::Some(GCProtoBufMsgSrc::GCProtoBufMsgSrc_Unspecified),
+            1 => ::std::option::Option::Some(GCProtoBufMsgSrc::GCProtoBufMsgSrc_FromSystem),
+            2 => ::std::option::Option::Some(GCProtoBufMsgSrc::GCProtoBufMsgSrc_FromSteamID),
+            3 => ::std::option::Option::Some(GCProtoBufMsgSrc::GCProtoBufMsgSrc_FromGC),
+            4 => ::std::option::Option::Some(GCProtoBufMsgSrc::GCProtoBufMsgSrc_ReplySystem),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn from_str(str: &str) -> ::std::option::Option<GCProtoBufMsgSrc> {
+        match str {
+            "GCProtoBufMsgSrc_Unspecified" => ::std::option::Option::Some(GCProtoBufMsgSrc::GCProtoBufMsgSrc_Unspecified),
+            "GCProtoBufMsgSrc_FromSystem" => ::std::option::Option::Some(GCProtoBufMsgSrc::GCProtoBufMsgSrc_FromSystem),
+            "GCProtoBufMsgSrc_FromSteamID" => ::std::option::Option::Some(GCProtoBufMsgSrc::GCProtoBufMsgSrc_FromSteamID),
+            "GCProtoBufMsgSrc_FromGC" => ::std::option::Option::Some(GCProtoBufMsgSrc::GCProtoBufMsgSrc_FromGC),
+            "GCProtoBufMsgSrc_ReplySystem" => ::std::option::Option::Some(GCProtoBufMsgSrc::GCProtoBufMsgSrc_ReplySystem),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    const VALUES: &'static [GCProtoBufMsgSrc] = &[
+        GCProtoBufMsgSrc::GCProtoBufMsgSrc_Unspecified,
+        GCProtoBufMsgSrc::GCProtoBufMsgSrc_FromSystem,
+        GCProtoBufMsgSrc::GCProtoBufMsgSrc_FromSteamID,
+        GCProtoBufMsgSrc::GCProtoBufMsgSrc_FromGC,
+        GCProtoBufMsgSrc::GCProtoBufMsgSrc_ReplySystem,
+    ];
+}
+
+impl ::std::default::Default for GCProtoBufMsgSrc {
+    fn default() -> Self {
+        GCProtoBufMsgSrc::GCProtoBufMsgSrc_Unspecified
+    }
+}
+
+
+// Extension generation with lite runtime is not supported
+
+
+const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;
+
+impl ::steam_vent_proto_common::RpcMessage for CMsgProtoBufHeader {
+    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 CChinaAgreementSessions_StartAgreementSessionInGame_Request {
+    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
+        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
+    }
+    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        use ::steam_vent_proto_common::protobuf::Message;
+        self.write_to_writer(writer)
+    }
+    fn encode_size(&self) -> usize {
+        use ::steam_vent_proto_common::protobuf::Message;
+        self.compute_size() as usize
+    }
+}
+impl ::steam_vent_proto_common::RpcMessage
+for CChinaAgreementSessions_StartAgreementSessionInGame_Response {
+    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
+        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
+    }
+    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        use ::steam_vent_proto_common::protobuf::Message;
+        self.write_to_writer(writer)
+    }
+    fn encode_size(&self) -> usize {
+        use ::steam_vent_proto_common::protobuf::Message;
+        self.compute_size() as usize
+    }
+}

src/generated/steammessages_helprequest_steamworkssdk.rs

@@ -0,0 +1,436 @@
+// This file is generated by rust-protobuf 3.5.1. Do not edit
+// .proto file is parsed by pure
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(dead_code)]
+#![allow(missing_docs)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+#![allow(trivial_casts)]
+#![allow(unused_results)]
+#![allow(unused_mut)]
+
+//! Generated file from `steammessages_helprequest.steamworkssdk.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;
+
+#[doc = "User uploading application logs"]
+// @@protoc_insertion_point(message:CHelpRequestLogs_UploadUserApplicationLog_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CHelpRequestLogs_UploadUserApplicationLog_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CHelpRequestLogs_UploadUserApplicationLog_Request.appid)
+    pub appid: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CHelpRequestLogs_UploadUserApplicationLog_Request.log_type)
+    pub log_type: ::std::option::Option<::std::string::String>,
+    // @@protoc_insertion_point(field:CHelpRequestLogs_UploadUserApplicationLog_Request.version_string)
+    pub version_string: ::std::option::Option<::std::string::String>,
+    // @@protoc_insertion_point(field:CHelpRequestLogs_UploadUserApplicationLog_Request.log_contents)
+    pub log_contents: ::std::option::Option<::std::string::String>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CHelpRequestLogs_UploadUserApplicationLog_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CHelpRequestLogs_UploadUserApplicationLog_Request {
+    fn default() -> &'a CHelpRequestLogs_UploadUserApplicationLog_Request {
+        <CHelpRequestLogs_UploadUserApplicationLog_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CHelpRequestLogs_UploadUserApplicationLog_Request {
+    pub fn new() -> CHelpRequestLogs_UploadUserApplicationLog_Request {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 appid = 1;
+
+    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 string log_type = 2;
+
+    pub fn log_type(&self) -> &str {
+        match self.log_type.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_log_type(&mut self) {
+        self.log_type = ::std::option::Option::None;
+    }
+
+    pub fn has_log_type(&self) -> bool {
+        self.log_type.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_log_type(&mut self, v: ::std::string::String) {
+        self.log_type = ::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_log_type(&mut self) -> &mut ::std::string::String {
+        if self.log_type.is_none() {
+            self.log_type = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.log_type.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_log_type(&mut self) -> ::std::string::String {
+        self.log_type.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional string version_string = 3;
+
+    pub fn version_string(&self) -> &str {
+        match self.version_string.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_version_string(&mut self) {
+        self.version_string = ::std::option::Option::None;
+    }
+
+    pub fn has_version_string(&self) -> bool {
+        self.version_string.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_version_string(&mut self, v: ::std::string::String) {
+        self.version_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_version_string(&mut self) -> &mut ::std::string::String {
+        if self.version_string.is_none() {
+            self.version_string = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.version_string.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_version_string(&mut self) -> ::std::string::String {
+        self.version_string.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional string log_contents = 4;
+
+    pub fn log_contents(&self) -> &str {
+        match self.log_contents.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_log_contents(&mut self) {
+        self.log_contents = ::std::option::Option::None;
+    }
+
+    pub fn has_log_contents(&self) -> bool {
+        self.log_contents.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_log_contents(&mut self, v: ::std::string::String) {
+        self.log_contents = ::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_log_contents(&mut self) -> &mut ::std::string::String {
+        if self.log_contents.is_none() {
+            self.log_contents = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.log_contents.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_log_contents(&mut self) -> ::std::string::String {
+        self.log_contents.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CHelpRequestLogs_UploadUserApplicationLog_Request {
+    const NAME: &'static str = "CHelpRequestLogs_UploadUserApplicationLog_Request";
+
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        while let Some(tag) = is.read_raw_tag_or_eof()? {
+            match tag {
+                8 => {
+                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                18 => {
+                    self.log_type = ::std::option::Option::Some(is.read_string()?);
+                },
+                26 => {
+                    self.version_string = ::std::option::Option::Some(is.read_string()?);
+                },
+                34 => {
+                    self.log_contents = ::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.appid {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.log_type.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
+        }
+        if let Some(v) = self.version_string.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
+        }
+        if let Some(v) = self.log_contents.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::string_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.appid {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.log_type.as_ref() {
+            os.write_string(2, v)?;
+        }
+        if let Some(v) = self.version_string.as_ref() {
+            os.write_string(3, v)?;
+        }
+        if let Some(v) = self.log_contents.as_ref() {
+            os.write_string(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() -> CHelpRequestLogs_UploadUserApplicationLog_Request {
+        CHelpRequestLogs_UploadUserApplicationLog_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.appid = ::std::option::Option::None;
+        self.log_type = ::std::option::Option::None;
+        self.version_string = ::std::option::Option::None;
+        self.log_contents = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CHelpRequestLogs_UploadUserApplicationLog_Request {
+        static instance: CHelpRequestLogs_UploadUserApplicationLog_Request = CHelpRequestLogs_UploadUserApplicationLog_Request {
+            appid: ::std::option::Option::None,
+            log_type: ::std::option::Option::None,
+            version_string: ::std::option::Option::None,
+            log_contents: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CHelpRequestLogs_UploadUserApplicationLog_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CHelpRequestLogs_UploadUserApplicationLog_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CHelpRequestLogs_UploadUserApplicationLog_Response.id)
+    pub id: ::std::option::Option<u64>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CHelpRequestLogs_UploadUserApplicationLog_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CHelpRequestLogs_UploadUserApplicationLog_Response {
+    fn default() -> &'a CHelpRequestLogs_UploadUserApplicationLog_Response {
+        <CHelpRequestLogs_UploadUserApplicationLog_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CHelpRequestLogs_UploadUserApplicationLog_Response {
+    pub fn new() -> CHelpRequestLogs_UploadUserApplicationLog_Response {
+        ::std::default::Default::default()
+    }
+
+    // optional uint64 id = 1;
+
+    pub fn id(&self) -> u64 {
+        self.id.unwrap_or(0)
+    }
+
+    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: u64) {
+        self.id = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CHelpRequestLogs_UploadUserApplicationLog_Response {
+    const NAME: &'static str = "CHelpRequestLogs_UploadUserApplicationLog_Response";
+
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        while let Some(tag) = is.read_raw_tag_or_eof()? {
+            match tag {
+                8 => {
+                    self.id = ::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.id {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
+        }
+        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        if let Some(v) = self.id {
+            os.write_uint64(1, v)?;
+        }
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> CHelpRequestLogs_UploadUserApplicationLog_Response {
+        CHelpRequestLogs_UploadUserApplicationLog_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.id = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CHelpRequestLogs_UploadUserApplicationLog_Response {
+        static instance: CHelpRequestLogs_UploadUserApplicationLog_Response = CHelpRequestLogs_UploadUserApplicationLog_Response {
+            id: ::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::steammessages_unified_base_steamworkssdk::*;
+impl ::steam_vent_proto_common::RpcMessage
+for CHelpRequestLogs_UploadUserApplicationLog_Request {
+    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
+        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
+    }
+    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        use ::steam_vent_proto_common::protobuf::Message;
+        self.write_to_writer(writer)
+    }
+    fn encode_size(&self) -> usize {
+        use ::steam_vent_proto_common::protobuf::Message;
+        self.compute_size() as usize
+    }
+}
+impl ::steam_vent_proto_common::RpcMessage
+for CHelpRequestLogs_UploadUserApplicationLog_Response {
+    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
+        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
+    }
+    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        use ::steam_vent_proto_common::protobuf::Message;
+        self.write_to_writer(writer)
+    }
+    fn encode_size(&self) -> usize {
+        use ::steam_vent_proto_common::protobuf::Message;
+        self.compute_size() as usize
+    }
+}
+///Service for dealing with user-submitted logs
+struct HelpRequestLogs {}
+impl ::steam_vent_proto_common::RpcService for HelpRequestLogs {
+    const SERVICE_NAME: &'static str = "HelpRequestLogs";
+}
+impl ::steam_vent_proto_common::RpcMethod
+for CHelpRequestLogs_UploadUserApplicationLog_Request {
+    const METHOD_NAME: &'static str = "HelpRequestLogs.UploadUserApplicationLog#1";
+    type Response = CHelpRequestLogs_UploadUserApplicationLog_Response;
+}

src/generated/steammessages_oauth_steamworkssdk.rs

@@ -0,0 +1,371 @@
+// This file is generated by rust-protobuf 3.5.1. Do not edit
+// .proto file is parsed by pure
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(dead_code)]
+#![allow(missing_docs)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+#![allow(trivial_casts)]
+#![allow(unused_results)]
+#![allow(unused_mut)]
+
+//! Generated file from `steammessages_oauth.steamworkssdk.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;
+
+#[doc = "Grants an implicit OAuth token (grant type 'token') for the specified client ID on behalf of a user without prompting"]
+// @@protoc_insertion_point(message:COAuthToken_ImplicitGrantNoPrompt_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct COAuthToken_ImplicitGrantNoPrompt_Request {
+    // message fields
+    // @@protoc_insertion_point(field:COAuthToken_ImplicitGrantNoPrompt_Request.clientid)
+    pub clientid: ::std::option::Option<::std::string::String>,
+    // special fields
+    // @@protoc_insertion_point(special_field:COAuthToken_ImplicitGrantNoPrompt_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a COAuthToken_ImplicitGrantNoPrompt_Request {
+    fn default() -> &'a COAuthToken_ImplicitGrantNoPrompt_Request {
+        <COAuthToken_ImplicitGrantNoPrompt_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl COAuthToken_ImplicitGrantNoPrompt_Request {
+    pub fn new() -> COAuthToken_ImplicitGrantNoPrompt_Request {
+        ::std::default::Default::default()
+    }
+
+    // optional string clientid = 1;
+
+    pub fn clientid(&self) -> &str {
+        match self.clientid.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_clientid(&mut self) {
+        self.clientid = ::std::option::Option::None;
+    }
+
+    pub fn has_clientid(&self) -> bool {
+        self.clientid.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_clientid(&mut self, v: ::std::string::String) {
+        self.clientid = ::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_clientid(&mut self) -> &mut ::std::string::String {
+        if self.clientid.is_none() {
+            self.clientid = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.clientid.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_clientid(&mut self) -> ::std::string::String {
+        self.clientid.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for COAuthToken_ImplicitGrantNoPrompt_Request {
+    const NAME: &'static str = "COAuthToken_ImplicitGrantNoPrompt_Request";
+
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        while let Some(tag) = is.read_raw_tag_or_eof()? {
+            match tag {
+                10 => {
+                    self.clientid = ::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.clientid.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.clientid.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() -> COAuthToken_ImplicitGrantNoPrompt_Request {
+        COAuthToken_ImplicitGrantNoPrompt_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.clientid = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static COAuthToken_ImplicitGrantNoPrompt_Request {
+        static instance: COAuthToken_ImplicitGrantNoPrompt_Request = COAuthToken_ImplicitGrantNoPrompt_Request {
+            clientid: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:COAuthToken_ImplicitGrantNoPrompt_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct COAuthToken_ImplicitGrantNoPrompt_Response {
+    // message fields
+    // @@protoc_insertion_point(field:COAuthToken_ImplicitGrantNoPrompt_Response.access_token)
+    pub access_token: ::std::option::Option<::std::string::String>,
+    // @@protoc_insertion_point(field:COAuthToken_ImplicitGrantNoPrompt_Response.redirect_uri)
+    pub redirect_uri: ::std::option::Option<::std::string::String>,
+    // special fields
+    // @@protoc_insertion_point(special_field:COAuthToken_ImplicitGrantNoPrompt_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a COAuthToken_ImplicitGrantNoPrompt_Response {
+    fn default() -> &'a COAuthToken_ImplicitGrantNoPrompt_Response {
+        <COAuthToken_ImplicitGrantNoPrompt_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl COAuthToken_ImplicitGrantNoPrompt_Response {
+    pub fn new() -> COAuthToken_ImplicitGrantNoPrompt_Response {
+        ::std::default::Default::default()
+    }
+
+    // optional string access_token = 1;
+
+    pub fn access_token(&self) -> &str {
+        match self.access_token.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_access_token(&mut self) {
+        self.access_token = ::std::option::Option::None;
+    }
+
+    pub fn has_access_token(&self) -> bool {
+        self.access_token.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_access_token(&mut self, v: ::std::string::String) {
+        self.access_token = ::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_access_token(&mut self) -> &mut ::std::string::String {
+        if self.access_token.is_none() {
+            self.access_token = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.access_token.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_access_token(&mut self) -> ::std::string::String {
+        self.access_token.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional string redirect_uri = 2;
+
+    pub fn redirect_uri(&self) -> &str {
+        match self.redirect_uri.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_redirect_uri(&mut self) {
+        self.redirect_uri = ::std::option::Option::None;
+    }
+
+    pub fn has_redirect_uri(&self) -> bool {
+        self.redirect_uri.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_redirect_uri(&mut self, v: ::std::string::String) {
+        self.redirect_uri = ::std::option::Option::Some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_redirect_uri(&mut self) -> &mut ::std::string::String {
+        if self.redirect_uri.is_none() {
+            self.redirect_uri = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.redirect_uri.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_redirect_uri(&mut self) -> ::std::string::String {
+        self.redirect_uri.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for COAuthToken_ImplicitGrantNoPrompt_Response {
+    const NAME: &'static str = "COAuthToken_ImplicitGrantNoPrompt_Response";
+
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        while let Some(tag) = is.read_raw_tag_or_eof()? {
+            match tag {
+                10 => {
+                    self.access_token = ::std::option::Option::Some(is.read_string()?);
+                },
+                18 => {
+                    self.redirect_uri = ::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.access_token.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
+        }
+        if let Some(v) = self.redirect_uri.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.access_token.as_ref() {
+            os.write_string(1, v)?;
+        }
+        if let Some(v) = self.redirect_uri.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() -> COAuthToken_ImplicitGrantNoPrompt_Response {
+        COAuthToken_ImplicitGrantNoPrompt_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.access_token = ::std::option::Option::None;
+        self.redirect_uri = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static COAuthToken_ImplicitGrantNoPrompt_Response {
+        static instance: COAuthToken_ImplicitGrantNoPrompt_Response = COAuthToken_ImplicitGrantNoPrompt_Response {
+            access_token: ::std::option::Option::None,
+            redirect_uri: ::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::steammessages_unified_base_steamworkssdk::*;
+impl ::steam_vent_proto_common::RpcMessage
+for COAuthToken_ImplicitGrantNoPrompt_Request {
+    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
+        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
+    }
+    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        use ::steam_vent_proto_common::protobuf::Message;
+        self.write_to_writer(writer)
+    }
+    fn encode_size(&self) -> usize {
+        use ::steam_vent_proto_common::protobuf::Message;
+        self.compute_size() as usize
+    }
+}
+impl ::steam_vent_proto_common::RpcMessage
+for COAuthToken_ImplicitGrantNoPrompt_Response {
+    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
+        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
+    }
+    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        use ::steam_vent_proto_common::protobuf::Message;
+        self.write_to_writer(writer)
+    }
+    fn encode_size(&self) -> usize {
+        use ::steam_vent_proto_common::protobuf::Message;
+        self.compute_size() as usize
+    }
+}
+///Service containing methods to manage OAuth tokens
+struct OAuthToken {}
+impl ::steam_vent_proto_common::RpcService for OAuthToken {
+    const SERVICE_NAME: &'static str = "OAuthToken";
+}
+impl ::steam_vent_proto_common::RpcMethod for COAuthToken_ImplicitGrantNoPrompt_Request {
+    const METHOD_NAME: &'static str = "OAuthToken.ImplicitGrantNoPrompt#1";
+    type Response = COAuthToken_ImplicitGrantNoPrompt_Response;
+}

src/generated/steammessages_unified_base_steamworkssdk.rs

@@ -0,0 +1,76 @@
+// This file is generated by rust-protobuf 3.5.1. Do not edit
+// .proto file is parsed by pure
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(dead_code)]
+#![allow(missing_docs)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+#![allow(trivial_casts)]
+#![allow(unused_results)]
+#![allow(unused_mut)]
+
+//! Generated file from `steammessages_unified_base.steamworkssdk.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;
+
+#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
+// @@protoc_insertion_point(enum:EProtoExecutionSite)
+pub enum EProtoExecutionSite {
+    // @@protoc_insertion_point(enum_value:EProtoExecutionSite.k_EProtoExecutionSiteUnknown)
+    k_EProtoExecutionSiteUnknown = 0,
+    // @@protoc_insertion_point(enum_value:EProtoExecutionSite.k_EProtoExecutionSiteSteamClient)
+    k_EProtoExecutionSiteSteamClient = 3,
+}
+
+impl ::steam_vent_proto_common::protobuf::Enum for EProtoExecutionSite {
+    const NAME: &'static str = "EProtoExecutionSite";
+
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<EProtoExecutionSite> {
+        match value {
+            0 => ::std::option::Option::Some(EProtoExecutionSite::k_EProtoExecutionSiteUnknown),
+            3 => ::std::option::Option::Some(EProtoExecutionSite::k_EProtoExecutionSiteSteamClient),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn from_str(str: &str) -> ::std::option::Option<EProtoExecutionSite> {
+        match str {
+            "k_EProtoExecutionSiteUnknown" => ::std::option::Option::Some(EProtoExecutionSite::k_EProtoExecutionSiteUnknown),
+            "k_EProtoExecutionSiteSteamClient" => ::std::option::Option::Some(EProtoExecutionSite::k_EProtoExecutionSiteSteamClient),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    const VALUES: &'static [EProtoExecutionSite] = &[
+        EProtoExecutionSite::k_EProtoExecutionSiteUnknown,
+        EProtoExecutionSite::k_EProtoExecutionSiteSteamClient,
+    ];
+}
+
+impl ::std::default::Default for EProtoExecutionSite {
+    fn default() -> Self {
+        EProtoExecutionSite::k_EProtoExecutionSiteUnknown
+    }
+}
+
+
+// Extension generation with lite runtime is not supported
+
+
+const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;

src/generated/uifontfile_format.rs

@@ -0,0 +1,491 @@
+// 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 `uifontfile_format.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:CUIFontFilePB)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CUIFontFilePB {
+    // message fields
+    // @@protoc_insertion_point(field:CUIFontFilePB.font_file_name)
+    pub font_file_name: ::std::option::Option<::std::string::String>,
+    // @@protoc_insertion_point(field:CUIFontFilePB.opentype_font_data)
+    pub opentype_font_data: ::std::option::Option<::std::vec::Vec<u8>>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CUIFontFilePB.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CUIFontFilePB {
+    fn default() -> &'a CUIFontFilePB {
+        <CUIFontFilePB as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CUIFontFilePB {
+    pub fn new() -> CUIFontFilePB {
+        ::std::default::Default::default()
+    }
+
+    // optional string font_file_name = 1;
+
+    pub fn font_file_name(&self) -> &str {
+        match self.font_file_name.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_font_file_name(&mut self) {
+        self.font_file_name = ::std::option::Option::None;
+    }
+
+    pub fn has_font_file_name(&self) -> bool {
+        self.font_file_name.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_font_file_name(&mut self, v: ::std::string::String) {
+        self.font_file_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_font_file_name(&mut self) -> &mut ::std::string::String {
+        if self.font_file_name.is_none() {
+            self.font_file_name = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.font_file_name.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_font_file_name(&mut self) -> ::std::string::String {
+        self.font_file_name.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional bytes opentype_font_data = 2;
+
+    pub fn opentype_font_data(&self) -> &[u8] {
+        match self.opentype_font_data.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_opentype_font_data(&mut self) {
+        self.opentype_font_data = ::std::option::Option::None;
+    }
+
+    pub fn has_opentype_font_data(&self) -> bool {
+        self.opentype_font_data.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_opentype_font_data(&mut self, v: ::std::vec::Vec<u8>) {
+        self.opentype_font_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_opentype_font_data(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.opentype_font_data.is_none() {
+            self.opentype_font_data = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.opentype_font_data.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_opentype_font_data(&mut self) -> ::std::vec::Vec<u8> {
+        self.opentype_font_data.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CUIFontFilePB {
+    const NAME: &'static str = "CUIFontFilePB";
+
+    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.font_file_name = ::std::option::Option::Some(is.read_string()?);
+                },
+                18 => {
+                    self.opentype_font_data = ::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.font_file_name.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
+        }
+        if let Some(v) = self.opentype_font_data.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.font_file_name.as_ref() {
+            os.write_string(1, v)?;
+        }
+        if let Some(v) = self.opentype_font_data.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() -> CUIFontFilePB {
+        CUIFontFilePB::new()
+    }
+
+    fn clear(&mut self) {
+        self.font_file_name = ::std::option::Option::None;
+        self.opentype_font_data = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CUIFontFilePB {
+        static instance: CUIFontFilePB = CUIFontFilePB {
+            font_file_name: ::std::option::Option::None,
+            opentype_font_data: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CUIFontFilePackagePB)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CUIFontFilePackagePB {
+    // message fields
+    // @@protoc_insertion_point(field:CUIFontFilePackagePB.package_version)
+    pub package_version: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CUIFontFilePackagePB.encrypted_font_files)
+    pub encrypted_font_files: ::std::vec::Vec<cuifont_file_package_pb::CUIEncryptedFontFilePB>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CUIFontFilePackagePB.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CUIFontFilePackagePB {
+    fn default() -> &'a CUIFontFilePackagePB {
+        <CUIFontFilePackagePB as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CUIFontFilePackagePB {
+    pub fn new() -> CUIFontFilePackagePB {
+        ::std::default::Default::default()
+    }
+
+    // required uint32 package_version = 1;
+
+    pub fn package_version(&self) -> u32 {
+        self.package_version.unwrap_or(0)
+    }
+
+    pub fn clear_package_version(&mut self) {
+        self.package_version = ::std::option::Option::None;
+    }
+
+    pub fn has_package_version(&self) -> bool {
+        self.package_version.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_package_version(&mut self, v: u32) {
+        self.package_version = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CUIFontFilePackagePB {
+    const NAME: &'static str = "CUIFontFilePackagePB";
+
+    fn is_initialized(&self) -> bool {
+        if self.package_version.is_none() {
+            return false;
+        }
+        for v in &self.encrypted_font_files {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        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.package_version = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                18 => {
+                    self.encrypted_font_files.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.package_version {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        for value in &self.encrypted_font_files {
+            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.package_version {
+            os.write_uint32(1, v)?;
+        }
+        for v in &self.encrypted_font_files {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
+        };
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> CUIFontFilePackagePB {
+        CUIFontFilePackagePB::new()
+    }
+
+    fn clear(&mut self) {
+        self.package_version = ::std::option::Option::None;
+        self.encrypted_font_files.clear();
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CUIFontFilePackagePB {
+        static instance: CUIFontFilePackagePB = CUIFontFilePackagePB {
+            package_version: ::std::option::Option::None,
+            encrypted_font_files: ::std::vec::Vec::new(),
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+/// Nested message and enums of message `CUIFontFilePackagePB`
+pub mod cuifont_file_package_pb {
+    // @@protoc_insertion_point(message:CUIFontFilePackagePB.CUIEncryptedFontFilePB)
+    #[derive(PartialEq,Clone,Default,Debug)]
+    pub struct CUIEncryptedFontFilePB {
+        // message fields
+        // @@protoc_insertion_point(field:CUIFontFilePackagePB.CUIEncryptedFontFilePB.encrypted_contents)
+        pub encrypted_contents: ::std::option::Option<::std::vec::Vec<u8>>,
+        // special fields
+        // @@protoc_insertion_point(special_field:CUIFontFilePackagePB.CUIEncryptedFontFilePB.special_fields)
+        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+    }
+
+    impl<'a> ::std::default::Default for &'a CUIEncryptedFontFilePB {
+        fn default() -> &'a CUIEncryptedFontFilePB {
+            <CUIEncryptedFontFilePB as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+        }
+    }
+
+    impl CUIEncryptedFontFilePB {
+        pub fn new() -> CUIEncryptedFontFilePB {
+            ::std::default::Default::default()
+        }
+
+        // optional bytes encrypted_contents = 1;
+
+        pub fn encrypted_contents(&self) -> &[u8] {
+            match self.encrypted_contents.as_ref() {
+                Some(v) => v,
+                None => &[],
+            }
+        }
+
+        pub fn clear_encrypted_contents(&mut self) {
+            self.encrypted_contents = ::std::option::Option::None;
+        }
+
+        pub fn has_encrypted_contents(&self) -> bool {
+            self.encrypted_contents.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_encrypted_contents(&mut self, v: ::std::vec::Vec<u8>) {
+            self.encrypted_contents = ::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_contents(&mut self) -> &mut ::std::vec::Vec<u8> {
+            if self.encrypted_contents.is_none() {
+                self.encrypted_contents = ::std::option::Option::Some(::std::vec::Vec::new());
+            }
+            self.encrypted_contents.as_mut().unwrap()
+        }
+
+        // Take field
+        pub fn take_encrypted_contents(&mut self) -> ::std::vec::Vec<u8> {
+            self.encrypted_contents.take().unwrap_or_else(|| ::std::vec::Vec::new())
+        }
+    }
+
+    impl ::steam_vent_proto_common::protobuf::Message for CUIEncryptedFontFilePB {
+        const NAME: &'static str = "CUIEncryptedFontFilePB";
+
+        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.encrypted_contents = ::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.encrypted_contents.as_ref() {
+                my_size += ::steam_vent_proto_common::protobuf::rt::bytes_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.encrypted_contents.as_ref() {
+                os.write_bytes(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() -> CUIEncryptedFontFilePB {
+            CUIEncryptedFontFilePB::new()
+        }
+
+        fn clear(&mut self) {
+            self.encrypted_contents = ::std::option::Option::None;
+            self.special_fields.clear();
+        }
+
+        fn default_instance() -> &'static CUIEncryptedFontFilePB {
+            static instance: CUIEncryptedFontFilePB = CUIEncryptedFontFilePB {
+                encrypted_contents: ::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;
+
+impl ::steam_vent_proto_common::RpcMessage for CUIFontFilePB {
+    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 CUIFontFilePackagePB {
+    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
+    }
+}

src/generated/valveextensions.rs

@@ -0,0 +1,31 @@
+// 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 `valveextensions.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;
+
+// Extension generation with lite runtime is not supported
+
+
+const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;

src/lib.rs

@@ -0,0 +1,5 @@
+//! steam-vent protobufs for csgo specific messages
+
+mod generated;
+
+pub use generated::*;