initial import from steam-vent repo

steam/src/generated/contenthubs.rs

@@ -0,0 +1,982 @@
+// 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 `contenthubs.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:CStorePageFilter)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CStorePageFilter {
+    // message fields
+    // @@protoc_insertion_point(field:CStorePageFilter.sale_filter)
+    pub sale_filter: ::steam_vent_proto_common::protobuf::MessageField<cstore_page_filter::SalePageFilter>,
+    // @@protoc_insertion_point(field:CStorePageFilter.content_hub_filter)
+    pub content_hub_filter: ::steam_vent_proto_common::protobuf::MessageField<cstore_page_filter::ContentHubFilter>,
+    // @@protoc_insertion_point(field:CStorePageFilter.store_filters)
+    pub store_filters: ::std::vec::Vec<cstore_page_filter::StoreFilter>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CStorePageFilter.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CStorePageFilter {
+    fn default() -> &'a CStorePageFilter {
+        <CStorePageFilter as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CStorePageFilter {
+    pub fn new() -> CStorePageFilter {
+        ::std::default::Default::default()
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CStorePageFilter {
+    const NAME: &'static str = "CStorePageFilter";
+
+    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.sale_filter)?;
+                },
+                18 => {
+                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.content_hub_filter)?;
+                },
+                26 => {
+                    self.store_filters.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.sale_filter.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.content_hub_filter.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.store_filters {
+            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.sale_filter.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
+        }
+        if let Some(v) = self.content_hub_filter.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
+        }
+        for v in &self.store_filters {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
+        };
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> CStorePageFilter {
+        CStorePageFilter::new()
+    }
+
+    fn clear(&mut self) {
+        self.sale_filter.clear();
+        self.content_hub_filter.clear();
+        self.store_filters.clear();
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CStorePageFilter {
+        static instance: CStorePageFilter = CStorePageFilter {
+            sale_filter: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            content_hub_filter: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            store_filters: ::std::vec::Vec::new(),
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+/// Nested message and enums of message `CStorePageFilter`
+pub mod cstore_page_filter {
+    // @@protoc_insertion_point(message:CStorePageFilter.SalePageFilter)
+    #[derive(PartialEq,Clone,Default,Debug)]
+    pub struct SalePageFilter {
+        // message fields
+        // @@protoc_insertion_point(field:CStorePageFilter.SalePageFilter.sale_tagid)
+        pub sale_tagid: ::std::option::Option<u32>,
+        // special fields
+        // @@protoc_insertion_point(special_field:CStorePageFilter.SalePageFilter.special_fields)
+        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+    }
+
+    impl<'a> ::std::default::Default for &'a SalePageFilter {
+        fn default() -> &'a SalePageFilter {
+            <SalePageFilter as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+        }
+    }
+
+    impl SalePageFilter {
+        pub fn new() -> SalePageFilter {
+            ::std::default::Default::default()
+        }
+
+        // optional uint32 sale_tagid = 1;
+
+        pub fn sale_tagid(&self) -> u32 {
+            self.sale_tagid.unwrap_or(0)
+        }
+
+        pub fn clear_sale_tagid(&mut self) {
+            self.sale_tagid = ::std::option::Option::None;
+        }
+
+        pub fn has_sale_tagid(&self) -> bool {
+            self.sale_tagid.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_sale_tagid(&mut self, v: u32) {
+            self.sale_tagid = ::std::option::Option::Some(v);
+        }
+    }
+
+    impl ::steam_vent_proto_common::protobuf::Message for SalePageFilter {
+        const NAME: &'static str = "SalePageFilter";
+
+        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.sale_tagid = ::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.sale_tagid {
+                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.sale_tagid {
+                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() -> SalePageFilter {
+            SalePageFilter::new()
+        }
+
+        fn clear(&mut self) {
+            self.sale_tagid = ::std::option::Option::None;
+            self.special_fields.clear();
+        }
+
+        fn default_instance() -> &'static SalePageFilter {
+            static instance: SalePageFilter = SalePageFilter {
+                sale_tagid: ::std::option::Option::None,
+                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+            };
+            &instance
+        }
+    }
+
+    // @@protoc_insertion_point(message:CStorePageFilter.ContentHubFilter)
+    #[derive(PartialEq,Clone,Default,Debug)]
+    pub struct ContentHubFilter {
+        // message fields
+        // @@protoc_insertion_point(field:CStorePageFilter.ContentHubFilter.hub_type)
+        pub hub_type: ::std::option::Option<::std::string::String>,
+        // @@protoc_insertion_point(field:CStorePageFilter.ContentHubFilter.hub_category)
+        pub hub_category: ::std::option::Option<::std::string::String>,
+        // @@protoc_insertion_point(field:CStorePageFilter.ContentHubFilter.hub_tagid)
+        pub hub_tagid: ::std::option::Option<u32>,
+        // @@protoc_insertion_point(field:CStorePageFilter.ContentHubFilter.discount_filter)
+        pub discount_filter: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::EContentHubDiscountFilterType>>,
+        // @@protoc_insertion_point(field:CStorePageFilter.ContentHubFilter.optin)
+        pub optin: ::steam_vent_proto_common::protobuf::MessageField<content_hub_filter::OptInInfo>,
+        // special fields
+        // @@protoc_insertion_point(special_field:CStorePageFilter.ContentHubFilter.special_fields)
+        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+    }
+
+    impl<'a> ::std::default::Default for &'a ContentHubFilter {
+        fn default() -> &'a ContentHubFilter {
+            <ContentHubFilter as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+        }
+    }
+
+    impl ContentHubFilter {
+        pub fn new() -> ContentHubFilter {
+            ::std::default::Default::default()
+        }
+
+        // optional string hub_type = 1;
+
+        pub fn hub_type(&self) -> &str {
+            match self.hub_type.as_ref() {
+                Some(v) => v,
+                None => "",
+            }
+        }
+
+        pub fn clear_hub_type(&mut self) {
+            self.hub_type = ::std::option::Option::None;
+        }
+
+        pub fn has_hub_type(&self) -> bool {
+            self.hub_type.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_hub_type(&mut self, v: ::std::string::String) {
+            self.hub_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_hub_type(&mut self) -> &mut ::std::string::String {
+            if self.hub_type.is_none() {
+                self.hub_type = ::std::option::Option::Some(::std::string::String::new());
+            }
+            self.hub_type.as_mut().unwrap()
+        }
+
+        // Take field
+        pub fn take_hub_type(&mut self) -> ::std::string::String {
+            self.hub_type.take().unwrap_or_else(|| ::std::string::String::new())
+        }
+
+        // optional string hub_category = 2;
+
+        pub fn hub_category(&self) -> &str {
+            match self.hub_category.as_ref() {
+                Some(v) => v,
+                None => "",
+            }
+        }
+
+        pub fn clear_hub_category(&mut self) {
+            self.hub_category = ::std::option::Option::None;
+        }
+
+        pub fn has_hub_category(&self) -> bool {
+            self.hub_category.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_hub_category(&mut self, v: ::std::string::String) {
+            self.hub_category = ::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_hub_category(&mut self) -> &mut ::std::string::String {
+            if self.hub_category.is_none() {
+                self.hub_category = ::std::option::Option::Some(::std::string::String::new());
+            }
+            self.hub_category.as_mut().unwrap()
+        }
+
+        // Take field
+        pub fn take_hub_category(&mut self) -> ::std::string::String {
+            self.hub_category.take().unwrap_or_else(|| ::std::string::String::new())
+        }
+
+        // optional uint32 hub_tagid = 3;
+
+        pub fn hub_tagid(&self) -> u32 {
+            self.hub_tagid.unwrap_or(0)
+        }
+
+        pub fn clear_hub_tagid(&mut self) {
+            self.hub_tagid = ::std::option::Option::None;
+        }
+
+        pub fn has_hub_tagid(&self) -> bool {
+            self.hub_tagid.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_hub_tagid(&mut self, v: u32) {
+            self.hub_tagid = ::std::option::Option::Some(v);
+        }
+
+        // optional .EContentHubDiscountFilterType discount_filter = 4;
+
+        pub fn discount_filter(&self) -> super::EContentHubDiscountFilterType {
+            match self.discount_filter {
+                Some(e) => e.enum_value_or(super::EContentHubDiscountFilterType::k_EContentHubDiscountFilterType_None),
+                None => super::EContentHubDiscountFilterType::k_EContentHubDiscountFilterType_None,
+            }
+        }
+
+        pub fn clear_discount_filter(&mut self) {
+            self.discount_filter = ::std::option::Option::None;
+        }
+
+        pub fn has_discount_filter(&self) -> bool {
+            self.discount_filter.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_discount_filter(&mut self, v: super::EContentHubDiscountFilterType) {
+            self.discount_filter = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
+        }
+    }
+
+    impl ::steam_vent_proto_common::protobuf::Message for ContentHubFilter {
+        const NAME: &'static str = "ContentHubFilter";
+
+        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.hub_type = ::std::option::Option::Some(is.read_string()?);
+                    },
+                    18 => {
+                        self.hub_category = ::std::option::Option::Some(is.read_string()?);
+                    },
+                    24 => {
+                        self.hub_tagid = ::std::option::Option::Some(is.read_uint32()?);
+                    },
+                    32 => {
+                        self.discount_filter = ::std::option::Option::Some(is.read_enum_or_unknown()?);
+                    },
+                    42 => {
+                        ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.optin)?;
+                    },
+                    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.hub_type.as_ref() {
+                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
+            }
+            if let Some(v) = self.hub_category.as_ref() {
+                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
+            }
+            if let Some(v) = self.hub_tagid {
+                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
+            }
+            if let Some(v) = self.discount_filter {
+                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v.value());
+            }
+            if let Some(v) = self.optin.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.hub_type.as_ref() {
+                os.write_string(1, v)?;
+            }
+            if let Some(v) = self.hub_category.as_ref() {
+                os.write_string(2, v)?;
+            }
+            if let Some(v) = self.hub_tagid {
+                os.write_uint32(3, v)?;
+            }
+            if let Some(v) = self.discount_filter {
+                os.write_enum(4, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
+            }
+            if let Some(v) = self.optin.as_ref() {
+                ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
+            }
+            os.write_unknown_fields(self.special_fields.unknown_fields())?;
+            ::std::result::Result::Ok(())
+        }
+
+        fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
+            &self.special_fields
+        }
+
+        fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
+            &mut self.special_fields
+        }
+
+        fn new() -> ContentHubFilter {
+            ContentHubFilter::new()
+        }
+
+        fn clear(&mut self) {
+            self.hub_type = ::std::option::Option::None;
+            self.hub_category = ::std::option::Option::None;
+            self.hub_tagid = ::std::option::Option::None;
+            self.discount_filter = ::std::option::Option::None;
+            self.optin.clear();
+            self.special_fields.clear();
+        }
+
+        fn default_instance() -> &'static ContentHubFilter {
+            static instance: ContentHubFilter = ContentHubFilter {
+                hub_type: ::std::option::Option::None,
+                hub_category: ::std::option::Option::None,
+                hub_tagid: ::std::option::Option::None,
+                discount_filter: ::std::option::Option::None,
+                optin: ::steam_vent_proto_common::protobuf::MessageField::none(),
+                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+            };
+            &instance
+        }
+    }
+
+    /// Nested message and enums of message `ContentHubFilter`
+    pub mod content_hub_filter {
+        // @@protoc_insertion_point(message:CStorePageFilter.ContentHubFilter.OptInInfo)
+        #[derive(PartialEq,Clone,Default,Debug)]
+        pub struct OptInInfo {
+            // message fields
+            // @@protoc_insertion_point(field:CStorePageFilter.ContentHubFilter.OptInInfo.name)
+            pub name: ::std::option::Option<::std::string::String>,
+            // @@protoc_insertion_point(field:CStorePageFilter.ContentHubFilter.OptInInfo.optin_tagid)
+            pub optin_tagid: ::std::option::Option<u32>,
+            // @@protoc_insertion_point(field:CStorePageFilter.ContentHubFilter.OptInInfo.prune_tagid)
+            pub prune_tagid: ::std::option::Option<u32>,
+            // @@protoc_insertion_point(field:CStorePageFilter.ContentHubFilter.OptInInfo.optin_only)
+            pub optin_only: ::std::option::Option<bool>,
+            // special fields
+            // @@protoc_insertion_point(special_field:CStorePageFilter.ContentHubFilter.OptInInfo.special_fields)
+            pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+        }
+
+        impl<'a> ::std::default::Default for &'a OptInInfo {
+            fn default() -> &'a OptInInfo {
+                <OptInInfo as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+            }
+        }
+
+        impl OptInInfo {
+            pub fn new() -> OptInInfo {
+                ::std::default::Default::default()
+            }
+
+            // optional string name = 1;
+
+            pub fn name(&self) -> &str {
+                match self.name.as_ref() {
+                    Some(v) => v,
+                    None => "",
+                }
+            }
+
+            pub fn clear_name(&mut self) {
+                self.name = ::std::option::Option::None;
+            }
+
+            pub fn has_name(&self) -> bool {
+                self.name.is_some()
+            }
+
+            // Param is passed by value, moved
+            pub fn set_name(&mut self, v: ::std::string::String) {
+                self.name = ::std::option::Option::Some(v);
+            }
+
+            // Mutable pointer to the field.
+            // If field is not initialized, it is initialized with default value first.
+            pub fn mut_name(&mut self) -> &mut ::std::string::String {
+                if self.name.is_none() {
+                    self.name = ::std::option::Option::Some(::std::string::String::new());
+                }
+                self.name.as_mut().unwrap()
+            }
+
+            // Take field
+            pub fn take_name(&mut self) -> ::std::string::String {
+                self.name.take().unwrap_or_else(|| ::std::string::String::new())
+            }
+
+            // optional uint32 optin_tagid = 2;
+
+            pub fn optin_tagid(&self) -> u32 {
+                self.optin_tagid.unwrap_or(0)
+            }
+
+            pub fn clear_optin_tagid(&mut self) {
+                self.optin_tagid = ::std::option::Option::None;
+            }
+
+            pub fn has_optin_tagid(&self) -> bool {
+                self.optin_tagid.is_some()
+            }
+
+            // Param is passed by value, moved
+            pub fn set_optin_tagid(&mut self, v: u32) {
+                self.optin_tagid = ::std::option::Option::Some(v);
+            }
+
+            // optional uint32 prune_tagid = 3;
+
+            pub fn prune_tagid(&self) -> u32 {
+                self.prune_tagid.unwrap_or(0)
+            }
+
+            pub fn clear_prune_tagid(&mut self) {
+                self.prune_tagid = ::std::option::Option::None;
+            }
+
+            pub fn has_prune_tagid(&self) -> bool {
+                self.prune_tagid.is_some()
+            }
+
+            // Param is passed by value, moved
+            pub fn set_prune_tagid(&mut self, v: u32) {
+                self.prune_tagid = ::std::option::Option::Some(v);
+            }
+
+            // optional bool optin_only = 4;
+
+            pub fn optin_only(&self) -> bool {
+                self.optin_only.unwrap_or(false)
+            }
+
+            pub fn clear_optin_only(&mut self) {
+                self.optin_only = ::std::option::Option::None;
+            }
+
+            pub fn has_optin_only(&self) -> bool {
+                self.optin_only.is_some()
+            }
+
+            // Param is passed by value, moved
+            pub fn set_optin_only(&mut self, v: bool) {
+                self.optin_only = ::std::option::Option::Some(v);
+            }
+        }
+
+        impl ::steam_vent_proto_common::protobuf::Message for OptInInfo {
+            const NAME: &'static str = "OptInInfo";
+
+            fn is_initialized(&self) -> bool {
+                true
+            }
+
+            fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+                while let Some(tag) = is.read_raw_tag_or_eof()? {
+                    match tag {
+                        10 => {
+                            self.name = ::std::option::Option::Some(is.read_string()?);
+                        },
+                        16 => {
+                            self.optin_tagid = ::std::option::Option::Some(is.read_uint32()?);
+                        },
+                        24 => {
+                            self.prune_tagid = ::std::option::Option::Some(is.read_uint32()?);
+                        },
+                        32 => {
+                            self.optin_only = ::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.name.as_ref() {
+                    my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
+                }
+                if let Some(v) = self.optin_tagid {
+                    my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
+                }
+                if let Some(v) = self.prune_tagid {
+                    my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
+                }
+                if let Some(v) = self.optin_only {
+                    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.name.as_ref() {
+                    os.write_string(1, v)?;
+                }
+                if let Some(v) = self.optin_tagid {
+                    os.write_uint32(2, v)?;
+                }
+                if let Some(v) = self.prune_tagid {
+                    os.write_uint32(3, v)?;
+                }
+                if let Some(v) = self.optin_only {
+                    os.write_bool(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() -> OptInInfo {
+                OptInInfo::new()
+            }
+
+            fn clear(&mut self) {
+                self.name = ::std::option::Option::None;
+                self.optin_tagid = ::std::option::Option::None;
+                self.prune_tagid = ::std::option::Option::None;
+                self.optin_only = ::std::option::Option::None;
+                self.special_fields.clear();
+            }
+
+            fn default_instance() -> &'static OptInInfo {
+                static instance: OptInInfo = OptInInfo {
+                    name: ::std::option::Option::None,
+                    optin_tagid: ::std::option::Option::None,
+                    prune_tagid: ::std::option::Option::None,
+                    optin_only: ::std::option::Option::None,
+                    special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+                };
+                &instance
+            }
+        }
+    }
+
+    // @@protoc_insertion_point(message:CStorePageFilter.StoreFilter)
+    #[derive(PartialEq,Clone,Default,Debug)]
+    pub struct StoreFilter {
+        // message fields
+        // @@protoc_insertion_point(field:CStorePageFilter.StoreFilter.filter_json)
+        pub filter_json: ::std::option::Option<::std::string::String>,
+        // @@protoc_insertion_point(field:CStorePageFilter.StoreFilter.cache_key)
+        pub cache_key: ::std::option::Option<::std::string::String>,
+        // special fields
+        // @@protoc_insertion_point(special_field:CStorePageFilter.StoreFilter.special_fields)
+        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+    }
+
+    impl<'a> ::std::default::Default for &'a StoreFilter {
+        fn default() -> &'a StoreFilter {
+            <StoreFilter as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+        }
+    }
+
+    impl StoreFilter {
+        pub fn new() -> StoreFilter {
+            ::std::default::Default::default()
+        }
+
+        // optional string filter_json = 1;
+
+        pub fn filter_json(&self) -> &str {
+            match self.filter_json.as_ref() {
+                Some(v) => v,
+                None => "",
+            }
+        }
+
+        pub fn clear_filter_json(&mut self) {
+            self.filter_json = ::std::option::Option::None;
+        }
+
+        pub fn has_filter_json(&self) -> bool {
+            self.filter_json.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_filter_json(&mut self, v: ::std::string::String) {
+            self.filter_json = ::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_filter_json(&mut self) -> &mut ::std::string::String {
+            if self.filter_json.is_none() {
+                self.filter_json = ::std::option::Option::Some(::std::string::String::new());
+            }
+            self.filter_json.as_mut().unwrap()
+        }
+
+        // Take field
+        pub fn take_filter_json(&mut self) -> ::std::string::String {
+            self.filter_json.take().unwrap_or_else(|| ::std::string::String::new())
+        }
+
+        // optional string cache_key = 2;
+
+        pub fn cache_key(&self) -> &str {
+            match self.cache_key.as_ref() {
+                Some(v) => v,
+                None => "",
+            }
+        }
+
+        pub fn clear_cache_key(&mut self) {
+            self.cache_key = ::std::option::Option::None;
+        }
+
+        pub fn has_cache_key(&self) -> bool {
+            self.cache_key.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_cache_key(&mut self, v: ::std::string::String) {
+            self.cache_key = ::std::option::Option::Some(v);
+        }
+
+        // Mutable pointer to the field.
+        // If field is not initialized, it is initialized with default value first.
+        pub fn mut_cache_key(&mut self) -> &mut ::std::string::String {
+            if self.cache_key.is_none() {
+                self.cache_key = ::std::option::Option::Some(::std::string::String::new());
+            }
+            self.cache_key.as_mut().unwrap()
+        }
+
+        // Take field
+        pub fn take_cache_key(&mut self) -> ::std::string::String {
+            self.cache_key.take().unwrap_or_else(|| ::std::string::String::new())
+        }
+    }
+
+    impl ::steam_vent_proto_common::protobuf::Message for StoreFilter {
+        const NAME: &'static str = "StoreFilter";
+
+        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.filter_json = ::std::option::Option::Some(is.read_string()?);
+                    },
+                    18 => {
+                        self.cache_key = ::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.filter_json.as_ref() {
+                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
+            }
+            if let Some(v) = self.cache_key.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.filter_json.as_ref() {
+                os.write_string(1, v)?;
+            }
+            if let Some(v) = self.cache_key.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() -> StoreFilter {
+            StoreFilter::new()
+        }
+
+        fn clear(&mut self) {
+            self.filter_json = ::std::option::Option::None;
+            self.cache_key = ::std::option::Option::None;
+            self.special_fields.clear();
+        }
+
+        fn default_instance() -> &'static StoreFilter {
+            static instance: StoreFilter = StoreFilter {
+                filter_json: ::std::option::Option::None,
+                cache_key: ::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:EContentHubDiscountFilterType)
+pub enum EContentHubDiscountFilterType {
+    // @@protoc_insertion_point(enum_value:EContentHubDiscountFilterType.k_EContentHubDiscountFilterType_None)
+    k_EContentHubDiscountFilterType_None = 0,
+    // @@protoc_insertion_point(enum_value:EContentHubDiscountFilterType.k_EContentHubDiscountFilterType_DiscountsOnly)
+    k_EContentHubDiscountFilterType_DiscountsOnly = 1,
+    // @@protoc_insertion_point(enum_value:EContentHubDiscountFilterType.k_EContentHubDiscountFilterType_PrioritizeDiscounts)
+    k_EContentHubDiscountFilterType_PrioritizeDiscounts = 2,
+}
+
+impl ::steam_vent_proto_common::protobuf::Enum for EContentHubDiscountFilterType {
+    const NAME: &'static str = "EContentHubDiscountFilterType";
+
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<EContentHubDiscountFilterType> {
+        match value {
+            0 => ::std::option::Option::Some(EContentHubDiscountFilterType::k_EContentHubDiscountFilterType_None),
+            1 => ::std::option::Option::Some(EContentHubDiscountFilterType::k_EContentHubDiscountFilterType_DiscountsOnly),
+            2 => ::std::option::Option::Some(EContentHubDiscountFilterType::k_EContentHubDiscountFilterType_PrioritizeDiscounts),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn from_str(str: &str) -> ::std::option::Option<EContentHubDiscountFilterType> {
+        match str {
+            "k_EContentHubDiscountFilterType_None" => ::std::option::Option::Some(EContentHubDiscountFilterType::k_EContentHubDiscountFilterType_None),
+            "k_EContentHubDiscountFilterType_DiscountsOnly" => ::std::option::Option::Some(EContentHubDiscountFilterType::k_EContentHubDiscountFilterType_DiscountsOnly),
+            "k_EContentHubDiscountFilterType_PrioritizeDiscounts" => ::std::option::Option::Some(EContentHubDiscountFilterType::k_EContentHubDiscountFilterType_PrioritizeDiscounts),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    const VALUES: &'static [EContentHubDiscountFilterType] = &[
+        EContentHubDiscountFilterType::k_EContentHubDiscountFilterType_None,
+        EContentHubDiscountFilterType::k_EContentHubDiscountFilterType_DiscountsOnly,
+        EContentHubDiscountFilterType::k_EContentHubDiscountFilterType_PrioritizeDiscounts,
+    ];
+}
+
+impl ::std::default::Default for EContentHubDiscountFilterType {
+    fn default() -> Self {
+        EContentHubDiscountFilterType::k_EContentHubDiscountFilterType_None
+    }
+}
+
+
+
+const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;
+
+#[allow(unused_imports)]
+use crate::steammessages_base::*;
+impl ::steam_vent_proto_common::RpcMessage for CStorePageFilter {
+    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
+    }
+}

steam/src/generated/encrypted_app_ticket.rs

@@ -0,0 +1,297 @@
+// 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 `encrypted_app_ticket.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:EncryptedAppTicket)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct EncryptedAppTicket {
+    // message fields
+    // @@protoc_insertion_point(field:EncryptedAppTicket.ticket_version_no)
+    pub ticket_version_no: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:EncryptedAppTicket.crc_encryptedticket)
+    pub crc_encryptedticket: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:EncryptedAppTicket.cb_encrypteduserdata)
+    pub cb_encrypteduserdata: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:EncryptedAppTicket.cb_encrypted_appownershipticket)
+    pub cb_encrypted_appownershipticket: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:EncryptedAppTicket.encrypted_ticket)
+    pub encrypted_ticket: ::std::option::Option<::std::vec::Vec<u8>>,
+    // special fields
+    // @@protoc_insertion_point(special_field:EncryptedAppTicket.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a EncryptedAppTicket {
+    fn default() -> &'a EncryptedAppTicket {
+        <EncryptedAppTicket as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl EncryptedAppTicket {
+    pub fn new() -> EncryptedAppTicket {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 ticket_version_no = 1;
+
+    pub fn ticket_version_no(&self) -> u32 {
+        self.ticket_version_no.unwrap_or(0)
+    }
+
+    pub fn clear_ticket_version_no(&mut self) {
+        self.ticket_version_no = ::std::option::Option::None;
+    }
+
+    pub fn has_ticket_version_no(&self) -> bool {
+        self.ticket_version_no.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_ticket_version_no(&mut self, v: u32) {
+        self.ticket_version_no = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 crc_encryptedticket = 2;
+
+    pub fn crc_encryptedticket(&self) -> u32 {
+        self.crc_encryptedticket.unwrap_or(0)
+    }
+
+    pub fn clear_crc_encryptedticket(&mut self) {
+        self.crc_encryptedticket = ::std::option::Option::None;
+    }
+
+    pub fn has_crc_encryptedticket(&self) -> bool {
+        self.crc_encryptedticket.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_crc_encryptedticket(&mut self, v: u32) {
+        self.crc_encryptedticket = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 cb_encrypteduserdata = 3;
+
+    pub fn cb_encrypteduserdata(&self) -> u32 {
+        self.cb_encrypteduserdata.unwrap_or(0)
+    }
+
+    pub fn clear_cb_encrypteduserdata(&mut self) {
+        self.cb_encrypteduserdata = ::std::option::Option::None;
+    }
+
+    pub fn has_cb_encrypteduserdata(&self) -> bool {
+        self.cb_encrypteduserdata.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_cb_encrypteduserdata(&mut self, v: u32) {
+        self.cb_encrypteduserdata = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 cb_encrypted_appownershipticket = 4;
+
+    pub fn cb_encrypted_appownershipticket(&self) -> u32 {
+        self.cb_encrypted_appownershipticket.unwrap_or(0)
+    }
+
+    pub fn clear_cb_encrypted_appownershipticket(&mut self) {
+        self.cb_encrypted_appownershipticket = ::std::option::Option::None;
+    }
+
+    pub fn has_cb_encrypted_appownershipticket(&self) -> bool {
+        self.cb_encrypted_appownershipticket.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_cb_encrypted_appownershipticket(&mut self, v: u32) {
+        self.cb_encrypted_appownershipticket = ::std::option::Option::Some(v);
+    }
+
+    // optional bytes encrypted_ticket = 5;
+
+    pub fn encrypted_ticket(&self) -> &[u8] {
+        match self.encrypted_ticket.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_encrypted_ticket(&mut self) {
+        self.encrypted_ticket = ::std::option::Option::None;
+    }
+
+    pub fn has_encrypted_ticket(&self) -> bool {
+        self.encrypted_ticket.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_encrypted_ticket(&mut self, v: ::std::vec::Vec<u8>) {
+        self.encrypted_ticket = ::std::option::Option::Some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_encrypted_ticket(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.encrypted_ticket.is_none() {
+            self.encrypted_ticket = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.encrypted_ticket.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_encrypted_ticket(&mut self) -> ::std::vec::Vec<u8> {
+        self.encrypted_ticket.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for EncryptedAppTicket {
+    const NAME: &'static str = "EncryptedAppTicket";
+
+    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.ticket_version_no = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                16 => {
+                    self.crc_encryptedticket = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                24 => {
+                    self.cb_encrypteduserdata = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                32 => {
+                    self.cb_encrypted_appownershipticket = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                42 => {
+                    self.encrypted_ticket = ::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.ticket_version_no {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.crc_encryptedticket {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
+        }
+        if let Some(v) = self.cb_encrypteduserdata {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
+        }
+        if let Some(v) = self.cb_encrypted_appownershipticket {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
+        }
+        if let Some(v) = self.encrypted_ticket.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(5, &v);
+        }
+        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        if let Some(v) = self.ticket_version_no {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.crc_encryptedticket {
+            os.write_uint32(2, v)?;
+        }
+        if let Some(v) = self.cb_encrypteduserdata {
+            os.write_uint32(3, v)?;
+        }
+        if let Some(v) = self.cb_encrypted_appownershipticket {
+            os.write_uint32(4, v)?;
+        }
+        if let Some(v) = self.encrypted_ticket.as_ref() {
+            os.write_bytes(5, v)?;
+        }
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> EncryptedAppTicket {
+        EncryptedAppTicket::new()
+    }
+
+    fn clear(&mut self) {
+        self.ticket_version_no = ::std::option::Option::None;
+        self.crc_encryptedticket = ::std::option::Option::None;
+        self.cb_encrypteduserdata = ::std::option::Option::None;
+        self.cb_encrypted_appownershipticket = ::std::option::Option::None;
+        self.encrypted_ticket = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static EncryptedAppTicket {
+        static instance: EncryptedAppTicket = EncryptedAppTicket {
+            ticket_version_no: ::std::option::Option::None,
+            crc_encryptedticket: ::std::option::Option::None,
+            cb_encrypteduserdata: ::std::option::Option::None,
+            cb_encrypted_appownershipticket: ::std::option::Option::None,
+            encrypted_ticket: ::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 EncryptedAppTicket {
+    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
+    }
+}

steam/src/generated/enums_productinfo.rs

@@ -0,0 +1,95 @@
+// 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 `enums_productinfo.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:EContentDescriptorID)
+pub enum EContentDescriptorID {
+    // @@protoc_insertion_point(enum_value:EContentDescriptorID.k_EContentDescriptor_NudityOrSexualContent)
+    k_EContentDescriptor_NudityOrSexualContent = 1,
+    // @@protoc_insertion_point(enum_value:EContentDescriptorID.k_EContentDescriptor_FrequentViolenceOrGore)
+    k_EContentDescriptor_FrequentViolenceOrGore = 2,
+    // @@protoc_insertion_point(enum_value:EContentDescriptorID.k_EContentDescriptor_AdultOnlySexualContent)
+    k_EContentDescriptor_AdultOnlySexualContent = 3,
+    // @@protoc_insertion_point(enum_value:EContentDescriptorID.k_EContentDescriptor_GratuitousSexualContent)
+    k_EContentDescriptor_GratuitousSexualContent = 4,
+    // @@protoc_insertion_point(enum_value:EContentDescriptorID.k_EContentDescriptor_AnyMatureContent)
+    k_EContentDescriptor_AnyMatureContent = 5,
+    // @@protoc_insertion_point(enum_value:EContentDescriptorID.k_EContentDescriptorMAX)
+    k_EContentDescriptorMAX = 6,
+}
+
+impl ::steam_vent_proto_common::protobuf::Enum for EContentDescriptorID {
+    const NAME: &'static str = "EContentDescriptorID";
+
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<EContentDescriptorID> {
+        match value {
+            1 => ::std::option::Option::Some(EContentDescriptorID::k_EContentDescriptor_NudityOrSexualContent),
+            2 => ::std::option::Option::Some(EContentDescriptorID::k_EContentDescriptor_FrequentViolenceOrGore),
+            3 => ::std::option::Option::Some(EContentDescriptorID::k_EContentDescriptor_AdultOnlySexualContent),
+            4 => ::std::option::Option::Some(EContentDescriptorID::k_EContentDescriptor_GratuitousSexualContent),
+            5 => ::std::option::Option::Some(EContentDescriptorID::k_EContentDescriptor_AnyMatureContent),
+            6 => ::std::option::Option::Some(EContentDescriptorID::k_EContentDescriptorMAX),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn from_str(str: &str) -> ::std::option::Option<EContentDescriptorID> {
+        match str {
+            "k_EContentDescriptor_NudityOrSexualContent" => ::std::option::Option::Some(EContentDescriptorID::k_EContentDescriptor_NudityOrSexualContent),
+            "k_EContentDescriptor_FrequentViolenceOrGore" => ::std::option::Option::Some(EContentDescriptorID::k_EContentDescriptor_FrequentViolenceOrGore),
+            "k_EContentDescriptor_AdultOnlySexualContent" => ::std::option::Option::Some(EContentDescriptorID::k_EContentDescriptor_AdultOnlySexualContent),
+            "k_EContentDescriptor_GratuitousSexualContent" => ::std::option::Option::Some(EContentDescriptorID::k_EContentDescriptor_GratuitousSexualContent),
+            "k_EContentDescriptor_AnyMatureContent" => ::std::option::Option::Some(EContentDescriptorID::k_EContentDescriptor_AnyMatureContent),
+            "k_EContentDescriptorMAX" => ::std::option::Option::Some(EContentDescriptorID::k_EContentDescriptorMAX),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    const VALUES: &'static [EContentDescriptorID] = &[
+        EContentDescriptorID::k_EContentDescriptor_NudityOrSexualContent,
+        EContentDescriptorID::k_EContentDescriptor_FrequentViolenceOrGore,
+        EContentDescriptorID::k_EContentDescriptor_AdultOnlySexualContent,
+        EContentDescriptorID::k_EContentDescriptor_GratuitousSexualContent,
+        EContentDescriptorID::k_EContentDescriptor_AnyMatureContent,
+        EContentDescriptorID::k_EContentDescriptorMAX,
+    ];
+}
+
+// Note, `Default` is implemented although default value is not 0
+impl ::std::default::Default for EContentDescriptorID {
+    fn default() -> Self {
+        EContentDescriptorID::k_EContentDescriptor_NudityOrSexualContent
+    }
+}
+
+
+
+const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;

steam/src/generated/mod.rs

@@ -0,0 +1,110 @@
+// @generated
+
+pub mod clientmetrics;
+pub mod content_manifest;
+pub mod contenthubs;
+pub mod encrypted_app_ticket;
+pub mod enums;
+pub mod enums_clientserver;
+pub mod enums_productinfo;
+pub mod htmlmessages;
+pub mod offline_ticket;
+pub mod steamdatagram_messages_auth;
+pub mod steamdatagram_messages_sdr;
+pub mod steammessages_accounthardware_steamclient;
+pub mod steammessages_appoverview;
+pub mod steammessages_auth_steamclient;
+pub mod steammessages_base;
+pub mod steammessages_broadcast_steamclient;
+pub mod steammessages_chat_steamclient;
+pub mod steammessages_client_objects;
+pub mod steammessages_clientlanp2p;
+pub mod steammessages_clientmetrics_steamclient;
+pub mod steammessages_clientnotificationtypes;
+pub mod steammessages_clientserver;
+pub mod steammessages_clientserver_2;
+pub mod steammessages_clientserver_appinfo;
+pub mod steammessages_clientserver_friends;
+pub mod steammessages_clientserver_gameservers;
+pub mod steammessages_clientserver_lbs;
+pub mod steammessages_clientserver_login;
+pub mod steammessages_clientserver_mms;
+pub mod steammessages_clientserver_ucm;
+pub mod steammessages_clientserver_uds;
+pub mod steammessages_clientserver_ufs;
+pub mod steammessages_clientserver_userstats;
+pub mod steammessages_clientserver_video;
+pub mod steammessages_clientsettings;
+pub mod steammessages_cloud_steamclient;
+pub mod steammessages_community_steamclient;
+pub mod steammessages_contentsystem_steamclient;
+pub mod steammessages_credentials_steamclient;
+pub mod steammessages_datapublisher_steamclient;
+pub mod steammessages_depotbuilder_steamclient;
+pub mod steammessages_deviceauth_steamclient;
+pub mod steammessages_econ_steamclient;
+pub mod steammessages_familygroups_steamclient;
+pub mod steammessages_friendmessages_steamclient;
+pub mod steammessages_gamenetworking_steamclient;
+pub mod steammessages_gamenetworkingui;
+pub mod steammessages_gamenotifications_steamclient;
+pub mod steammessages_gamerecording_objects;
+pub mod steammessages_gamerecording_steamclient;
+pub mod steammessages_gameservers_steamclient;
+pub mod steammessages_hiddevices;
+pub mod steammessages_inventory_steamclient;
+pub mod steammessages_linkfilter_steamclient;
+pub mod steammessages_lobbymatchmaking_steamclient;
+pub mod steammessages_market_steamclient;
+pub mod steammessages_marketingmessages_steamclient;
+pub mod steammessages_notifications_steamclient;
+pub mod steammessages_offline_steamclient;
+pub mod steammessages_parental_objects;
+pub mod steammessages_parental_steamclient;
+pub mod steammessages_parties_steamclient;
+pub mod steammessages_partnerapps_steamclient;
+pub mod steammessages_player_steamclient;
+pub mod steammessages_publishedfile_steamclient;
+pub mod steammessages_qms_steamclient;
+pub mod steammessages_remoteclient;
+pub mod steammessages_remoteclient_discovery;
+pub mod steammessages_remoteclient_service_messages;
+pub mod steammessages_remoteclient_service_steamclient;
+pub mod steammessages_remoteplay;
+pub mod steammessages_secrets_steamclient;
+pub mod steammessages_shader_steamclient;
+pub mod steammessages_site_license_steamclient;
+pub mod steammessages_sitelicenseclient;
+pub mod steammessages_siteserverui;
+pub mod steammessages_star_steamclient;
+pub mod steammessages_steamtv_steamclient;
+pub mod steammessages_store_steamclient;
+pub mod steammessages_storebrowse_steamclient;
+pub mod steammessages_timedtrial_steamclient;
+pub mod steammessages_twofactor_steamclient;
+pub mod steammessages_unified_base_steamclient;
+pub mod steammessages_unified_test_steamclient;
+pub mod steammessages_useraccount_steamclient;
+pub mod steammessages_vac_steamclient;
+pub mod steammessages_video_steamclient;
+pub mod steammessages_virtualcontroller;
+pub mod steammessages_workshop_steamclient;
+pub mod steamnetworkingsockets_messages;
+pub mod steamnetworkingsockets_messages_certs;
+pub mod steamnetworkingsockets_messages_udp;
+pub mod webuimessages_achievements;
+pub mod webuimessages_base;
+pub mod webuimessages_bluetooth;
+pub mod webuimessages_gamenotes;
+pub mod webuimessages_gamerecording;
+pub mod webuimessages_gamerecordingfiles;
+pub mod webuimessages_gamescope;
+pub mod webuimessages_services;
+pub mod webuimessages_sharedjscontext;
+pub mod webuimessages_steamengine;
+pub mod webuimessages_steaminput;
+pub mod webuimessages_steamos;
+pub mod webuimessages_storagedevicemanager;
+pub mod webuimessages_systemmanager;
+pub mod webuimessages_transport;
+pub mod webuimessages_transportvalidation;

steam/src/generated/offline_ticket.rs

@@ -0,0 +1,380 @@
+// 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 `offline_ticket.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:Offline_Ticket)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct Offline_Ticket {
+    // message fields
+    // @@protoc_insertion_point(field:Offline_Ticket.encrypted_ticket)
+    pub encrypted_ticket: ::std::option::Option<::std::vec::Vec<u8>>,
+    // @@protoc_insertion_point(field:Offline_Ticket.signature)
+    pub signature: ::std::option::Option<::std::vec::Vec<u8>>,
+    // @@protoc_insertion_point(field:Offline_Ticket.kdf1)
+    pub kdf1: ::std::option::Option<i32>,
+    // @@protoc_insertion_point(field:Offline_Ticket.salt1)
+    pub salt1: ::std::option::Option<::std::vec::Vec<u8>>,
+    // @@protoc_insertion_point(field:Offline_Ticket.kdf2)
+    pub kdf2: ::std::option::Option<i32>,
+    // @@protoc_insertion_point(field:Offline_Ticket.salt2)
+    pub salt2: ::std::option::Option<::std::vec::Vec<u8>>,
+    // special fields
+    // @@protoc_insertion_point(special_field:Offline_Ticket.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a Offline_Ticket {
+    fn default() -> &'a Offline_Ticket {
+        <Offline_Ticket as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl Offline_Ticket {
+    pub fn new() -> Offline_Ticket {
+        ::std::default::Default::default()
+    }
+
+    // optional bytes encrypted_ticket = 1;
+
+    pub fn encrypted_ticket(&self) -> &[u8] {
+        match self.encrypted_ticket.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_encrypted_ticket(&mut self) {
+        self.encrypted_ticket = ::std::option::Option::None;
+    }
+
+    pub fn has_encrypted_ticket(&self) -> bool {
+        self.encrypted_ticket.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_encrypted_ticket(&mut self, v: ::std::vec::Vec<u8>) {
+        self.encrypted_ticket = ::std::option::Option::Some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_encrypted_ticket(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.encrypted_ticket.is_none() {
+            self.encrypted_ticket = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.encrypted_ticket.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_encrypted_ticket(&mut self) -> ::std::vec::Vec<u8> {
+        self.encrypted_ticket.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    // optional bytes signature = 2;
+
+    pub fn signature(&self) -> &[u8] {
+        match self.signature.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_signature(&mut self) {
+        self.signature = ::std::option::Option::None;
+    }
+
+    pub fn has_signature(&self) -> bool {
+        self.signature.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_signature(&mut self, v: ::std::vec::Vec<u8>) {
+        self.signature = ::std::option::Option::Some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_signature(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.signature.is_none() {
+            self.signature = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.signature.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_signature(&mut self) -> ::std::vec::Vec<u8> {
+        self.signature.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    // optional int32 kdf1 = 3;
+
+    pub fn kdf1(&self) -> i32 {
+        self.kdf1.unwrap_or(0)
+    }
+
+    pub fn clear_kdf1(&mut self) {
+        self.kdf1 = ::std::option::Option::None;
+    }
+
+    pub fn has_kdf1(&self) -> bool {
+        self.kdf1.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_kdf1(&mut self, v: i32) {
+        self.kdf1 = ::std::option::Option::Some(v);
+    }
+
+    // optional bytes salt1 = 4;
+
+    pub fn salt1(&self) -> &[u8] {
+        match self.salt1.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_salt1(&mut self) {
+        self.salt1 = ::std::option::Option::None;
+    }
+
+    pub fn has_salt1(&self) -> bool {
+        self.salt1.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_salt1(&mut self, v: ::std::vec::Vec<u8>) {
+        self.salt1 = ::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_salt1(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.salt1.is_none() {
+            self.salt1 = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.salt1.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_salt1(&mut self) -> ::std::vec::Vec<u8> {
+        self.salt1.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    // optional int32 kdf2 = 5;
+
+    pub fn kdf2(&self) -> i32 {
+        self.kdf2.unwrap_or(0)
+    }
+
+    pub fn clear_kdf2(&mut self) {
+        self.kdf2 = ::std::option::Option::None;
+    }
+
+    pub fn has_kdf2(&self) -> bool {
+        self.kdf2.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_kdf2(&mut self, v: i32) {
+        self.kdf2 = ::std::option::Option::Some(v);
+    }
+
+    // optional bytes salt2 = 6;
+
+    pub fn salt2(&self) -> &[u8] {
+        match self.salt2.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_salt2(&mut self) {
+        self.salt2 = ::std::option::Option::None;
+    }
+
+    pub fn has_salt2(&self) -> bool {
+        self.salt2.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_salt2(&mut self, v: ::std::vec::Vec<u8>) {
+        self.salt2 = ::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_salt2(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.salt2.is_none() {
+            self.salt2 = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.salt2.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_salt2(&mut self) -> ::std::vec::Vec<u8> {
+        self.salt2.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for Offline_Ticket {
+    const NAME: &'static str = "Offline_Ticket";
+
+    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_ticket = ::std::option::Option::Some(is.read_bytes()?);
+                },
+                18 => {
+                    self.signature = ::std::option::Option::Some(is.read_bytes()?);
+                },
+                24 => {
+                    self.kdf1 = ::std::option::Option::Some(is.read_int32()?);
+                },
+                34 => {
+                    self.salt1 = ::std::option::Option::Some(is.read_bytes()?);
+                },
+                40 => {
+                    self.kdf2 = ::std::option::Option::Some(is.read_int32()?);
+                },
+                50 => {
+                    self.salt2 = ::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_ticket.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(1, &v);
+        }
+        if let Some(v) = self.signature.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(2, &v);
+        }
+        if let Some(v) = self.kdf1 {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v);
+        }
+        if let Some(v) = self.salt1.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(4, &v);
+        }
+        if let Some(v) = self.kdf2 {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v);
+        }
+        if let Some(v) = self.salt2.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(6, &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_ticket.as_ref() {
+            os.write_bytes(1, v)?;
+        }
+        if let Some(v) = self.signature.as_ref() {
+            os.write_bytes(2, v)?;
+        }
+        if let Some(v) = self.kdf1 {
+            os.write_int32(3, v)?;
+        }
+        if let Some(v) = self.salt1.as_ref() {
+            os.write_bytes(4, v)?;
+        }
+        if let Some(v) = self.kdf2 {
+            os.write_int32(5, v)?;
+        }
+        if let Some(v) = self.salt2.as_ref() {
+            os.write_bytes(6, 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() -> Offline_Ticket {
+        Offline_Ticket::new()
+    }
+
+    fn clear(&mut self) {
+        self.encrypted_ticket = ::std::option::Option::None;
+        self.signature = ::std::option::Option::None;
+        self.kdf1 = ::std::option::Option::None;
+        self.salt1 = ::std::option::Option::None;
+        self.kdf2 = ::std::option::Option::None;
+        self.salt2 = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static Offline_Ticket {
+        static instance: Offline_Ticket = Offline_Ticket {
+            encrypted_ticket: ::std::option::Option::None,
+            signature: ::std::option::Option::None,
+            kdf1: ::std::option::Option::None,
+            salt1: ::std::option::Option::None,
+            kdf2: ::std::option::Option::None,
+            salt2: ::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 Offline_Ticket {
+    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
+    }
+}

steam/src/generated/steammessages_gamenetworking_steamclient.rs

@@ -0,0 +1,511 @@
+// 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_gamenetworking.steamclient.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:CGameNetworking_AllocateFakeIP_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CGameNetworking_AllocateFakeIP_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CGameNetworking_AllocateFakeIP_Request.app_id)
+    pub app_id: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CGameNetworking_AllocateFakeIP_Request.num_fake_ports)
+    pub num_fake_ports: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CGameNetworking_AllocateFakeIP_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CGameNetworking_AllocateFakeIP_Request {
+    fn default() -> &'a CGameNetworking_AllocateFakeIP_Request {
+        <CGameNetworking_AllocateFakeIP_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CGameNetworking_AllocateFakeIP_Request {
+    pub fn new() -> CGameNetworking_AllocateFakeIP_Request {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 app_id = 1;
+
+    pub fn app_id(&self) -> u32 {
+        self.app_id.unwrap_or(0)
+    }
+
+    pub fn clear_app_id(&mut self) {
+        self.app_id = ::std::option::Option::None;
+    }
+
+    pub fn has_app_id(&self) -> bool {
+        self.app_id.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_app_id(&mut self, v: u32) {
+        self.app_id = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 num_fake_ports = 2;
+
+    pub fn num_fake_ports(&self) -> u32 {
+        self.num_fake_ports.unwrap_or(0)
+    }
+
+    pub fn clear_num_fake_ports(&mut self) {
+        self.num_fake_ports = ::std::option::Option::None;
+    }
+
+    pub fn has_num_fake_ports(&self) -> bool {
+        self.num_fake_ports.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_num_fake_ports(&mut self, v: u32) {
+        self.num_fake_ports = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CGameNetworking_AllocateFakeIP_Request {
+    const NAME: &'static str = "CGameNetworking_AllocateFakeIP_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.app_id = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                16 => {
+                    self.num_fake_ports = ::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.app_id {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.num_fake_ports {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_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.app_id {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.num_fake_ports {
+            os.write_uint32(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() -> CGameNetworking_AllocateFakeIP_Request {
+        CGameNetworking_AllocateFakeIP_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.app_id = ::std::option::Option::None;
+        self.num_fake_ports = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CGameNetworking_AllocateFakeIP_Request {
+        static instance: CGameNetworking_AllocateFakeIP_Request = CGameNetworking_AllocateFakeIP_Request {
+            app_id: ::std::option::Option::None,
+            num_fake_ports: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CGameNetworking_AllocateFakeIP_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CGameNetworking_AllocateFakeIP_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CGameNetworking_AllocateFakeIP_Response.fake_ip)
+    pub fake_ip: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CGameNetworking_AllocateFakeIP_Response.fake_ports)
+    pub fake_ports: ::std::vec::Vec<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CGameNetworking_AllocateFakeIP_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CGameNetworking_AllocateFakeIP_Response {
+    fn default() -> &'a CGameNetworking_AllocateFakeIP_Response {
+        <CGameNetworking_AllocateFakeIP_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CGameNetworking_AllocateFakeIP_Response {
+    pub fn new() -> CGameNetworking_AllocateFakeIP_Response {
+        ::std::default::Default::default()
+    }
+
+    // optional fixed32 fake_ip = 1;
+
+    pub fn fake_ip(&self) -> u32 {
+        self.fake_ip.unwrap_or(0)
+    }
+
+    pub fn clear_fake_ip(&mut self) {
+        self.fake_ip = ::std::option::Option::None;
+    }
+
+    pub fn has_fake_ip(&self) -> bool {
+        self.fake_ip.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_fake_ip(&mut self, v: u32) {
+        self.fake_ip = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CGameNetworking_AllocateFakeIP_Response {
+    const NAME: &'static str = "CGameNetworking_AllocateFakeIP_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 {
+                13 => {
+                    self.fake_ip = ::std::option::Option::Some(is.read_fixed32()?);
+                },
+                18 => {
+                    is.read_repeated_packed_uint32_into(&mut self.fake_ports)?;
+                },
+                16 => {
+                    self.fake_ports.push(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.fake_ip {
+            my_size += 1 + 4;
+        }
+        for value in &self.fake_ports {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, *value);
+        };
+        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        if let Some(v) = self.fake_ip {
+            os.write_fixed32(1, v)?;
+        }
+        for v in &self.fake_ports {
+            os.write_uint32(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() -> CGameNetworking_AllocateFakeIP_Response {
+        CGameNetworking_AllocateFakeIP_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.fake_ip = ::std::option::Option::None;
+        self.fake_ports.clear();
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CGameNetworking_AllocateFakeIP_Response {
+        static instance: CGameNetworking_AllocateFakeIP_Response = CGameNetworking_AllocateFakeIP_Response {
+            fake_ip: ::std::option::Option::None,
+            fake_ports: ::std::vec::Vec::new(),
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CGameNetworking_ReleaseFakeIP_Notification)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CGameNetworking_ReleaseFakeIP_Notification {
+    // message fields
+    // @@protoc_insertion_point(field:CGameNetworking_ReleaseFakeIP_Notification.app_id)
+    pub app_id: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CGameNetworking_ReleaseFakeIP_Notification.fake_ip)
+    pub fake_ip: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CGameNetworking_ReleaseFakeIP_Notification.fake_ports)
+    pub fake_ports: ::std::vec::Vec<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CGameNetworking_ReleaseFakeIP_Notification.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CGameNetworking_ReleaseFakeIP_Notification {
+    fn default() -> &'a CGameNetworking_ReleaseFakeIP_Notification {
+        <CGameNetworking_ReleaseFakeIP_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CGameNetworking_ReleaseFakeIP_Notification {
+    pub fn new() -> CGameNetworking_ReleaseFakeIP_Notification {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 app_id = 1;
+
+    pub fn app_id(&self) -> u32 {
+        self.app_id.unwrap_or(0)
+    }
+
+    pub fn clear_app_id(&mut self) {
+        self.app_id = ::std::option::Option::None;
+    }
+
+    pub fn has_app_id(&self) -> bool {
+        self.app_id.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_app_id(&mut self, v: u32) {
+        self.app_id = ::std::option::Option::Some(v);
+    }
+
+    // optional fixed32 fake_ip = 2;
+
+    pub fn fake_ip(&self) -> u32 {
+        self.fake_ip.unwrap_or(0)
+    }
+
+    pub fn clear_fake_ip(&mut self) {
+        self.fake_ip = ::std::option::Option::None;
+    }
+
+    pub fn has_fake_ip(&self) -> bool {
+        self.fake_ip.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_fake_ip(&mut self, v: u32) {
+        self.fake_ip = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CGameNetworking_ReleaseFakeIP_Notification {
+    const NAME: &'static str = "CGameNetworking_ReleaseFakeIP_Notification";
+
+    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.app_id = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                21 => {
+                    self.fake_ip = ::std::option::Option::Some(is.read_fixed32()?);
+                },
+                26 => {
+                    is.read_repeated_packed_uint32_into(&mut self.fake_ports)?;
+                },
+                24 => {
+                    self.fake_ports.push(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.app_id {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.fake_ip {
+            my_size += 1 + 4;
+        }
+        for value in &self.fake_ports {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, *value);
+        };
+        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        if let Some(v) = self.app_id {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.fake_ip {
+            os.write_fixed32(2, v)?;
+        }
+        for v in &self.fake_ports {
+            os.write_uint32(3, *v)?;
+        };
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> CGameNetworking_ReleaseFakeIP_Notification {
+        CGameNetworking_ReleaseFakeIP_Notification::new()
+    }
+
+    fn clear(&mut self) {
+        self.app_id = ::std::option::Option::None;
+        self.fake_ip = ::std::option::Option::None;
+        self.fake_ports.clear();
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CGameNetworking_ReleaseFakeIP_Notification {
+        static instance: CGameNetworking_ReleaseFakeIP_Notification = CGameNetworking_ReleaseFakeIP_Notification {
+            app_id: ::std::option::Option::None,
+            fake_ip: ::std::option::Option::None,
+            fake_ports: ::std::vec::Vec::new(),
+            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_base::*;
+#[allow(unused_imports)]
+use crate::steammessages_unified_base_steamclient::*;
+impl ::steam_vent_proto_common::RpcMessage for CGameNetworking_AllocateFakeIP_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 CGameNetworking_AllocateFakeIP_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
+    }
+}
+impl ::steam_vent_proto_common::RpcMessage
+for CGameNetworking_ReleaseFakeIP_Notification {
+    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
+    }
+}
+///
+struct GameNetworking {}
+impl ::steam_vent_proto_common::RpcService for GameNetworking {
+    const SERVICE_NAME: &'static str = "GameNetworking";
+}
+impl ::steam_vent_proto_common::RpcMethod for CGameNetworking_AllocateFakeIP_Request {
+    const METHOD_NAME: &'static str = "GameNetworking.AllocateFakeIP#1";
+    type Response = CGameNetworking_AllocateFakeIP_Response;
+}
+impl ::steam_vent_proto_common::RpcMethod
+for CGameNetworking_ReleaseFakeIP_Notification {
+    const METHOD_NAME: &'static str = "GameNetworking.NotifyReleaseFakeIP#1";
+    type Response = ();
+}

steam/src/generated/steammessages_gamerecording_objects.rs

@@ -0,0 +1,571 @@
+// 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_gamerecording_objects.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:CGameRecording_AudioSessionsChanged_Notification)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CGameRecording_AudioSessionsChanged_Notification {
+    // message fields
+    // @@protoc_insertion_point(field:CGameRecording_AudioSessionsChanged_Notification.sessions)
+    pub sessions: ::std::vec::Vec<cgame_recording_audio_sessions_changed_notification::Session>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CGameRecording_AudioSessionsChanged_Notification.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CGameRecording_AudioSessionsChanged_Notification {
+    fn default() -> &'a CGameRecording_AudioSessionsChanged_Notification {
+        <CGameRecording_AudioSessionsChanged_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CGameRecording_AudioSessionsChanged_Notification {
+    pub fn new() -> CGameRecording_AudioSessionsChanged_Notification {
+        ::std::default::Default::default()
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CGameRecording_AudioSessionsChanged_Notification {
+    const NAME: &'static str = "CGameRecording_AudioSessionsChanged_Notification";
+
+    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.sessions.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;
+        for value in &self.sessions {
+            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<()> {
+        for v in &self.sessions {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, 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() -> CGameRecording_AudioSessionsChanged_Notification {
+        CGameRecording_AudioSessionsChanged_Notification::new()
+    }
+
+    fn clear(&mut self) {
+        self.sessions.clear();
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CGameRecording_AudioSessionsChanged_Notification {
+        static instance: CGameRecording_AudioSessionsChanged_Notification = CGameRecording_AudioSessionsChanged_Notification {
+            sessions: ::std::vec::Vec::new(),
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+/// Nested message and enums of message `CGameRecording_AudioSessionsChanged_Notification`
+pub mod cgame_recording_audio_sessions_changed_notification {
+    // @@protoc_insertion_point(message:CGameRecording_AudioSessionsChanged_Notification.Session)
+    #[derive(PartialEq,Clone,Default,Debug)]
+    pub struct Session {
+        // message fields
+        // @@protoc_insertion_point(field:CGameRecording_AudioSessionsChanged_Notification.Session.id)
+        pub id: ::std::option::Option<::std::string::String>,
+        // @@protoc_insertion_point(field:CGameRecording_AudioSessionsChanged_Notification.Session.name)
+        pub name: ::std::option::Option<::std::string::String>,
+        // @@protoc_insertion_point(field:CGameRecording_AudioSessionsChanged_Notification.Session.is_system)
+        pub is_system: ::std::option::Option<bool>,
+        // @@protoc_insertion_point(field:CGameRecording_AudioSessionsChanged_Notification.Session.is_muted)
+        pub is_muted: ::std::option::Option<bool>,
+        // @@protoc_insertion_point(field:CGameRecording_AudioSessionsChanged_Notification.Session.is_active)
+        pub is_active: ::std::option::Option<bool>,
+        // @@protoc_insertion_point(field:CGameRecording_AudioSessionsChanged_Notification.Session.is_captured)
+        pub is_captured: ::std::option::Option<bool>,
+        // @@protoc_insertion_point(field:CGameRecording_AudioSessionsChanged_Notification.Session.recent_peak)
+        pub recent_peak: ::std::option::Option<f32>,
+        // @@protoc_insertion_point(field:CGameRecording_AudioSessionsChanged_Notification.Session.is_game)
+        pub is_game: ::std::option::Option<bool>,
+        // @@protoc_insertion_point(field:CGameRecording_AudioSessionsChanged_Notification.Session.is_steam)
+        pub is_steam: ::std::option::Option<bool>,
+        // @@protoc_insertion_point(field:CGameRecording_AudioSessionsChanged_Notification.Session.is_saved)
+        pub is_saved: ::std::option::Option<bool>,
+        // special fields
+        // @@protoc_insertion_point(special_field:CGameRecording_AudioSessionsChanged_Notification.Session.special_fields)
+        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+    }
+
+    impl<'a> ::std::default::Default for &'a Session {
+        fn default() -> &'a Session {
+            <Session as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+        }
+    }
+
+    impl Session {
+        pub fn new() -> Session {
+            ::std::default::Default::default()
+        }
+
+        // optional string id = 1;
+
+        pub fn id(&self) -> &str {
+            match self.id.as_ref() {
+                Some(v) => v,
+                None => "",
+            }
+        }
+
+        pub fn clear_id(&mut self) {
+            self.id = ::std::option::Option::None;
+        }
+
+        pub fn has_id(&self) -> bool {
+            self.id.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_id(&mut self, v: ::std::string::String) {
+            self.id = ::std::option::Option::Some(v);
+        }
+
+        // Mutable pointer to the field.
+        // If field is not initialized, it is initialized with default value first.
+        pub fn mut_id(&mut self) -> &mut ::std::string::String {
+            if self.id.is_none() {
+                self.id = ::std::option::Option::Some(::std::string::String::new());
+            }
+            self.id.as_mut().unwrap()
+        }
+
+        // Take field
+        pub fn take_id(&mut self) -> ::std::string::String {
+            self.id.take().unwrap_or_else(|| ::std::string::String::new())
+        }
+
+        // optional string name = 2;
+
+        pub fn name(&self) -> &str {
+            match self.name.as_ref() {
+                Some(v) => v,
+                None => "",
+            }
+        }
+
+        pub fn clear_name(&mut self) {
+            self.name = ::std::option::Option::None;
+        }
+
+        pub fn has_name(&self) -> bool {
+            self.name.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_name(&mut self, v: ::std::string::String) {
+            self.name = ::std::option::Option::Some(v);
+        }
+
+        // Mutable pointer to the field.
+        // If field is not initialized, it is initialized with default value first.
+        pub fn mut_name(&mut self) -> &mut ::std::string::String {
+            if self.name.is_none() {
+                self.name = ::std::option::Option::Some(::std::string::String::new());
+            }
+            self.name.as_mut().unwrap()
+        }
+
+        // Take field
+        pub fn take_name(&mut self) -> ::std::string::String {
+            self.name.take().unwrap_or_else(|| ::std::string::String::new())
+        }
+
+        // optional bool is_system = 3;
+
+        pub fn is_system(&self) -> bool {
+            self.is_system.unwrap_or(false)
+        }
+
+        pub fn clear_is_system(&mut self) {
+            self.is_system = ::std::option::Option::None;
+        }
+
+        pub fn has_is_system(&self) -> bool {
+            self.is_system.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_is_system(&mut self, v: bool) {
+            self.is_system = ::std::option::Option::Some(v);
+        }
+
+        // optional bool is_muted = 4;
+
+        pub fn is_muted(&self) -> bool {
+            self.is_muted.unwrap_or(false)
+        }
+
+        pub fn clear_is_muted(&mut self) {
+            self.is_muted = ::std::option::Option::None;
+        }
+
+        pub fn has_is_muted(&self) -> bool {
+            self.is_muted.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_is_muted(&mut self, v: bool) {
+            self.is_muted = ::std::option::Option::Some(v);
+        }
+
+        // optional bool is_active = 5;
+
+        pub fn is_active(&self) -> bool {
+            self.is_active.unwrap_or(false)
+        }
+
+        pub fn clear_is_active(&mut self) {
+            self.is_active = ::std::option::Option::None;
+        }
+
+        pub fn has_is_active(&self) -> bool {
+            self.is_active.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_is_active(&mut self, v: bool) {
+            self.is_active = ::std::option::Option::Some(v);
+        }
+
+        // optional bool is_captured = 6;
+
+        pub fn is_captured(&self) -> bool {
+            self.is_captured.unwrap_or(false)
+        }
+
+        pub fn clear_is_captured(&mut self) {
+            self.is_captured = ::std::option::Option::None;
+        }
+
+        pub fn has_is_captured(&self) -> bool {
+            self.is_captured.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_is_captured(&mut self, v: bool) {
+            self.is_captured = ::std::option::Option::Some(v);
+        }
+
+        // optional float recent_peak = 7;
+
+        pub fn recent_peak(&self) -> f32 {
+            self.recent_peak.unwrap_or(0.)
+        }
+
+        pub fn clear_recent_peak(&mut self) {
+            self.recent_peak = ::std::option::Option::None;
+        }
+
+        pub fn has_recent_peak(&self) -> bool {
+            self.recent_peak.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_recent_peak(&mut self, v: f32) {
+            self.recent_peak = ::std::option::Option::Some(v);
+        }
+
+        // optional bool is_game = 8;
+
+        pub fn is_game(&self) -> bool {
+            self.is_game.unwrap_or(false)
+        }
+
+        pub fn clear_is_game(&mut self) {
+            self.is_game = ::std::option::Option::None;
+        }
+
+        pub fn has_is_game(&self) -> bool {
+            self.is_game.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_is_game(&mut self, v: bool) {
+            self.is_game = ::std::option::Option::Some(v);
+        }
+
+        // optional bool is_steam = 9;
+
+        pub fn is_steam(&self) -> bool {
+            self.is_steam.unwrap_or(false)
+        }
+
+        pub fn clear_is_steam(&mut self) {
+            self.is_steam = ::std::option::Option::None;
+        }
+
+        pub fn has_is_steam(&self) -> bool {
+            self.is_steam.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_is_steam(&mut self, v: bool) {
+            self.is_steam = ::std::option::Option::Some(v);
+        }
+
+        // optional bool is_saved = 10;
+
+        pub fn is_saved(&self) -> bool {
+            self.is_saved.unwrap_or(false)
+        }
+
+        pub fn clear_is_saved(&mut self) {
+            self.is_saved = ::std::option::Option::None;
+        }
+
+        pub fn has_is_saved(&self) -> bool {
+            self.is_saved.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_is_saved(&mut self, v: bool) {
+            self.is_saved = ::std::option::Option::Some(v);
+        }
+    }
+
+    impl ::steam_vent_proto_common::protobuf::Message for Session {
+        const NAME: &'static str = "Session";
+
+        fn is_initialized(&self) -> bool {
+            true
+        }
+
+        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+            while let Some(tag) = is.read_raw_tag_or_eof()? {
+                match tag {
+                    10 => {
+                        self.id = ::std::option::Option::Some(is.read_string()?);
+                    },
+                    18 => {
+                        self.name = ::std::option::Option::Some(is.read_string()?);
+                    },
+                    24 => {
+                        self.is_system = ::std::option::Option::Some(is.read_bool()?);
+                    },
+                    32 => {
+                        self.is_muted = ::std::option::Option::Some(is.read_bool()?);
+                    },
+                    40 => {
+                        self.is_active = ::std::option::Option::Some(is.read_bool()?);
+                    },
+                    48 => {
+                        self.is_captured = ::std::option::Option::Some(is.read_bool()?);
+                    },
+                    61 => {
+                        self.recent_peak = ::std::option::Option::Some(is.read_float()?);
+                    },
+                    64 => {
+                        self.is_game = ::std::option::Option::Some(is.read_bool()?);
+                    },
+                    72 => {
+                        self.is_steam = ::std::option::Option::Some(is.read_bool()?);
+                    },
+                    80 => {
+                        self.is_saved = ::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.id.as_ref() {
+                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
+            }
+            if let Some(v) = self.name.as_ref() {
+                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
+            }
+            if let Some(v) = self.is_system {
+                my_size += 1 + 1;
+            }
+            if let Some(v) = self.is_muted {
+                my_size += 1 + 1;
+            }
+            if let Some(v) = self.is_active {
+                my_size += 1 + 1;
+            }
+            if let Some(v) = self.is_captured {
+                my_size += 1 + 1;
+            }
+            if let Some(v) = self.recent_peak {
+                my_size += 1 + 4;
+            }
+            if let Some(v) = self.is_game {
+                my_size += 1 + 1;
+            }
+            if let Some(v) = self.is_steam {
+                my_size += 1 + 1;
+            }
+            if let Some(v) = self.is_saved {
+                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.id.as_ref() {
+                os.write_string(1, v)?;
+            }
+            if let Some(v) = self.name.as_ref() {
+                os.write_string(2, v)?;
+            }
+            if let Some(v) = self.is_system {
+                os.write_bool(3, v)?;
+            }
+            if let Some(v) = self.is_muted {
+                os.write_bool(4, v)?;
+            }
+            if let Some(v) = self.is_active {
+                os.write_bool(5, v)?;
+            }
+            if let Some(v) = self.is_captured {
+                os.write_bool(6, v)?;
+            }
+            if let Some(v) = self.recent_peak {
+                os.write_float(7, v)?;
+            }
+            if let Some(v) = self.is_game {
+                os.write_bool(8, v)?;
+            }
+            if let Some(v) = self.is_steam {
+                os.write_bool(9, v)?;
+            }
+            if let Some(v) = self.is_saved {
+                os.write_bool(10, v)?;
+            }
+            os.write_unknown_fields(self.special_fields.unknown_fields())?;
+            ::std::result::Result::Ok(())
+        }
+
+        fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
+            &self.special_fields
+        }
+
+        fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
+            &mut self.special_fields
+        }
+
+        fn new() -> Session {
+            Session::new()
+        }
+
+        fn clear(&mut self) {
+            self.id = ::std::option::Option::None;
+            self.name = ::std::option::Option::None;
+            self.is_system = ::std::option::Option::None;
+            self.is_muted = ::std::option::Option::None;
+            self.is_active = ::std::option::Option::None;
+            self.is_captured = ::std::option::Option::None;
+            self.recent_peak = ::std::option::Option::None;
+            self.is_game = ::std::option::Option::None;
+            self.is_steam = ::std::option::Option::None;
+            self.is_saved = ::std::option::Option::None;
+            self.special_fields.clear();
+        }
+
+        fn default_instance() -> &'static Session {
+            static instance: Session = Session {
+                id: ::std::option::Option::None,
+                name: ::std::option::Option::None,
+                is_system: ::std::option::Option::None,
+                is_muted: ::std::option::Option::None,
+                is_active: ::std::option::Option::None,
+                is_captured: ::std::option::Option::None,
+                recent_peak: ::std::option::Option::None,
+                is_game: ::std::option::Option::None,
+                is_steam: ::std::option::Option::None,
+                is_saved: ::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::enums::*;
+impl ::steam_vent_proto_common::RpcMessage
+for CGameRecording_AudioSessionsChanged_Notification {
+    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
+    }
+}

steam/src/generated/steammessages_linkfilter_steamclient.rs

@@ -0,0 +1,931 @@
+// 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_linkfilter.steamclient.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:CCommunity_GetLinkFilterHashPrefixes_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CCommunity_GetLinkFilterHashPrefixes_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CCommunity_GetLinkFilterHashPrefixes_Request.hit_type)
+    pub hit_type: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CCommunity_GetLinkFilterHashPrefixes_Request.count)
+    pub count: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CCommunity_GetLinkFilterHashPrefixes_Request.start)
+    pub start: ::std::option::Option<u64>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CCommunity_GetLinkFilterHashPrefixes_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CCommunity_GetLinkFilterHashPrefixes_Request {
+    fn default() -> &'a CCommunity_GetLinkFilterHashPrefixes_Request {
+        <CCommunity_GetLinkFilterHashPrefixes_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CCommunity_GetLinkFilterHashPrefixes_Request {
+    pub fn new() -> CCommunity_GetLinkFilterHashPrefixes_Request {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 hit_type = 1;
+
+    pub fn hit_type(&self) -> u32 {
+        self.hit_type.unwrap_or(0)
+    }
+
+    pub fn clear_hit_type(&mut self) {
+        self.hit_type = ::std::option::Option::None;
+    }
+
+    pub fn has_hit_type(&self) -> bool {
+        self.hit_type.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_hit_type(&mut self, v: u32) {
+        self.hit_type = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 count = 2;
+
+    pub fn count(&self) -> u32 {
+        self.count.unwrap_or(0)
+    }
+
+    pub fn clear_count(&mut self) {
+        self.count = ::std::option::Option::None;
+    }
+
+    pub fn has_count(&self) -> bool {
+        self.count.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_count(&mut self, v: u32) {
+        self.count = ::std::option::Option::Some(v);
+    }
+
+    // optional uint64 start = 3;
+
+    pub fn start(&self) -> u64 {
+        self.start.unwrap_or(0)
+    }
+
+    pub fn clear_start(&mut self) {
+        self.start = ::std::option::Option::None;
+    }
+
+    pub fn has_start(&self) -> bool {
+        self.start.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_start(&mut self, v: u64) {
+        self.start = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CCommunity_GetLinkFilterHashPrefixes_Request {
+    const NAME: &'static str = "CCommunity_GetLinkFilterHashPrefixes_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.hit_type = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                16 => {
+                    self.count = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                24 => {
+                    self.start = ::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.hit_type {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.count {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
+        }
+        if let Some(v) = self.start {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.hit_type {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.count {
+            os.write_uint32(2, v)?;
+        }
+        if let Some(v) = self.start {
+            os.write_uint64(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() -> CCommunity_GetLinkFilterHashPrefixes_Request {
+        CCommunity_GetLinkFilterHashPrefixes_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.hit_type = ::std::option::Option::None;
+        self.count = ::std::option::Option::None;
+        self.start = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CCommunity_GetLinkFilterHashPrefixes_Request {
+        static instance: CCommunity_GetLinkFilterHashPrefixes_Request = CCommunity_GetLinkFilterHashPrefixes_Request {
+            hit_type: ::std::option::Option::None,
+            count: ::std::option::Option::None,
+            start: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CCommunity_GetLinkFilterHashPrefixes_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CCommunity_GetLinkFilterHashPrefixes_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CCommunity_GetLinkFilterHashPrefixes_Response.hash_prefixes)
+    pub hash_prefixes: ::std::vec::Vec<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CCommunity_GetLinkFilterHashPrefixes_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CCommunity_GetLinkFilterHashPrefixes_Response {
+    fn default() -> &'a CCommunity_GetLinkFilterHashPrefixes_Response {
+        <CCommunity_GetLinkFilterHashPrefixes_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CCommunity_GetLinkFilterHashPrefixes_Response {
+    pub fn new() -> CCommunity_GetLinkFilterHashPrefixes_Response {
+        ::std::default::Default::default()
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CCommunity_GetLinkFilterHashPrefixes_Response {
+    const NAME: &'static str = "CCommunity_GetLinkFilterHashPrefixes_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 => {
+                    is.read_repeated_packed_uint32_into(&mut self.hash_prefixes)?;
+                },
+                8 => {
+                    self.hash_prefixes.push(is.read_uint32()?);
+                },
+                tag => {
+                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u64 {
+        let mut my_size = 0;
+        for value in &self.hash_prefixes {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, *value);
+        };
+        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        for v in &self.hash_prefixes {
+            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() -> CCommunity_GetLinkFilterHashPrefixes_Response {
+        CCommunity_GetLinkFilterHashPrefixes_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.hash_prefixes.clear();
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CCommunity_GetLinkFilterHashPrefixes_Response {
+        static instance: CCommunity_GetLinkFilterHashPrefixes_Response = CCommunity_GetLinkFilterHashPrefixes_Response {
+            hash_prefixes: ::std::vec::Vec::new(),
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CCommunity_GetLinkFilterHashes_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CCommunity_GetLinkFilterHashes_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CCommunity_GetLinkFilterHashes_Request.hit_type)
+    pub hit_type: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CCommunity_GetLinkFilterHashes_Request.count)
+    pub count: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CCommunity_GetLinkFilterHashes_Request.start)
+    pub start: ::std::option::Option<u64>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CCommunity_GetLinkFilterHashes_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CCommunity_GetLinkFilterHashes_Request {
+    fn default() -> &'a CCommunity_GetLinkFilterHashes_Request {
+        <CCommunity_GetLinkFilterHashes_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CCommunity_GetLinkFilterHashes_Request {
+    pub fn new() -> CCommunity_GetLinkFilterHashes_Request {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 hit_type = 1;
+
+    pub fn hit_type(&self) -> u32 {
+        self.hit_type.unwrap_or(0)
+    }
+
+    pub fn clear_hit_type(&mut self) {
+        self.hit_type = ::std::option::Option::None;
+    }
+
+    pub fn has_hit_type(&self) -> bool {
+        self.hit_type.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_hit_type(&mut self, v: u32) {
+        self.hit_type = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 count = 2;
+
+    pub fn count(&self) -> u32 {
+        self.count.unwrap_or(0)
+    }
+
+    pub fn clear_count(&mut self) {
+        self.count = ::std::option::Option::None;
+    }
+
+    pub fn has_count(&self) -> bool {
+        self.count.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_count(&mut self, v: u32) {
+        self.count = ::std::option::Option::Some(v);
+    }
+
+    // optional uint64 start = 3;
+
+    pub fn start(&self) -> u64 {
+        self.start.unwrap_or(0)
+    }
+
+    pub fn clear_start(&mut self) {
+        self.start = ::std::option::Option::None;
+    }
+
+    pub fn has_start(&self) -> bool {
+        self.start.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_start(&mut self, v: u64) {
+        self.start = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CCommunity_GetLinkFilterHashes_Request {
+    const NAME: &'static str = "CCommunity_GetLinkFilterHashes_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.hit_type = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                16 => {
+                    self.count = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                24 => {
+                    self.start = ::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.hit_type {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.count {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
+        }
+        if let Some(v) = self.start {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.hit_type {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.count {
+            os.write_uint32(2, v)?;
+        }
+        if let Some(v) = self.start {
+            os.write_uint64(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() -> CCommunity_GetLinkFilterHashes_Request {
+        CCommunity_GetLinkFilterHashes_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.hit_type = ::std::option::Option::None;
+        self.count = ::std::option::Option::None;
+        self.start = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CCommunity_GetLinkFilterHashes_Request {
+        static instance: CCommunity_GetLinkFilterHashes_Request = CCommunity_GetLinkFilterHashes_Request {
+            hit_type: ::std::option::Option::None,
+            count: ::std::option::Option::None,
+            start: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CCommunity_GetLinkFilterHashes_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CCommunity_GetLinkFilterHashes_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CCommunity_GetLinkFilterHashes_Response.hashes)
+    pub hashes: ::std::vec::Vec<::std::vec::Vec<u8>>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CCommunity_GetLinkFilterHashes_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CCommunity_GetLinkFilterHashes_Response {
+    fn default() -> &'a CCommunity_GetLinkFilterHashes_Response {
+        <CCommunity_GetLinkFilterHashes_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CCommunity_GetLinkFilterHashes_Response {
+    pub fn new() -> CCommunity_GetLinkFilterHashes_Response {
+        ::std::default::Default::default()
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CCommunity_GetLinkFilterHashes_Response {
+    const NAME: &'static str = "CCommunity_GetLinkFilterHashes_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.hashes.push(is.read_bytes()?);
+                },
+                tag => {
+                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u64 {
+        let mut my_size = 0;
+        for value in &self.hashes {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(1, &value);
+        };
+        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        for v in &self.hashes {
+            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() -> CCommunity_GetLinkFilterHashes_Response {
+        CCommunity_GetLinkFilterHashes_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.hashes.clear();
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CCommunity_GetLinkFilterHashes_Response {
+        static instance: CCommunity_GetLinkFilterHashes_Response = CCommunity_GetLinkFilterHashes_Response {
+            hashes: ::std::vec::Vec::new(),
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CCommunity_GetLinkFilterListVersion_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CCommunity_GetLinkFilterListVersion_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CCommunity_GetLinkFilterListVersion_Request.hit_type)
+    pub hit_type: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CCommunity_GetLinkFilterListVersion_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CCommunity_GetLinkFilterListVersion_Request {
+    fn default() -> &'a CCommunity_GetLinkFilterListVersion_Request {
+        <CCommunity_GetLinkFilterListVersion_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CCommunity_GetLinkFilterListVersion_Request {
+    pub fn new() -> CCommunity_GetLinkFilterListVersion_Request {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 hit_type = 1;
+
+    pub fn hit_type(&self) -> u32 {
+        self.hit_type.unwrap_or(0)
+    }
+
+    pub fn clear_hit_type(&mut self) {
+        self.hit_type = ::std::option::Option::None;
+    }
+
+    pub fn has_hit_type(&self) -> bool {
+        self.hit_type.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_hit_type(&mut self, v: u32) {
+        self.hit_type = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CCommunity_GetLinkFilterListVersion_Request {
+    const NAME: &'static str = "CCommunity_GetLinkFilterListVersion_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.hit_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.hit_type {
+            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.hit_type {
+            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() -> CCommunity_GetLinkFilterListVersion_Request {
+        CCommunity_GetLinkFilterListVersion_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.hit_type = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CCommunity_GetLinkFilterListVersion_Request {
+        static instance: CCommunity_GetLinkFilterListVersion_Request = CCommunity_GetLinkFilterListVersion_Request {
+            hit_type: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CCommunity_GetLinkFilterListVersion_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CCommunity_GetLinkFilterListVersion_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CCommunity_GetLinkFilterListVersion_Response.version)
+    pub version: ::std::option::Option<::std::string::String>,
+    // @@protoc_insertion_point(field:CCommunity_GetLinkFilterListVersion_Response.count)
+    pub count: ::std::option::Option<u64>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CCommunity_GetLinkFilterListVersion_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CCommunity_GetLinkFilterListVersion_Response {
+    fn default() -> &'a CCommunity_GetLinkFilterListVersion_Response {
+        <CCommunity_GetLinkFilterListVersion_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CCommunity_GetLinkFilterListVersion_Response {
+    pub fn new() -> CCommunity_GetLinkFilterListVersion_Response {
+        ::std::default::Default::default()
+    }
+
+    // optional string version = 1;
+
+    pub fn version(&self) -> &str {
+        match self.version.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_version(&mut self) {
+        self.version = ::std::option::Option::None;
+    }
+
+    pub fn has_version(&self) -> bool {
+        self.version.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_version(&mut self, v: ::std::string::String) {
+        self.version = ::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(&mut self) -> &mut ::std::string::String {
+        if self.version.is_none() {
+            self.version = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.version.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_version(&mut self) -> ::std::string::String {
+        self.version.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional uint64 count = 2;
+
+    pub fn count(&self) -> u64 {
+        self.count.unwrap_or(0)
+    }
+
+    pub fn clear_count(&mut self) {
+        self.count = ::std::option::Option::None;
+    }
+
+    pub fn has_count(&self) -> bool {
+        self.count.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_count(&mut self, v: u64) {
+        self.count = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CCommunity_GetLinkFilterListVersion_Response {
+    const NAME: &'static str = "CCommunity_GetLinkFilterListVersion_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.version = ::std::option::Option::Some(is.read_string()?);
+                },
+                16 => {
+                    self.count = ::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.version.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
+        }
+        if let Some(v) = self.count {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.version.as_ref() {
+            os.write_string(1, v)?;
+        }
+        if let Some(v) = self.count {
+            os.write_uint64(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() -> CCommunity_GetLinkFilterListVersion_Response {
+        CCommunity_GetLinkFilterListVersion_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.version = ::std::option::Option::None;
+        self.count = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CCommunity_GetLinkFilterListVersion_Response {
+        static instance: CCommunity_GetLinkFilterListVersion_Response = CCommunity_GetLinkFilterListVersion_Response {
+            version: ::std::option::Option::None,
+            count: ::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_base::*;
+#[allow(unused_imports)]
+use crate::steammessages_unified_base_steamclient::*;
+impl ::steam_vent_proto_common::RpcMessage
+for CCommunity_GetLinkFilterHashPrefixes_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 CCommunity_GetLinkFilterHashPrefixes_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
+    }
+}
+impl ::steam_vent_proto_common::RpcMessage for CCommunity_GetLinkFilterHashes_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 CCommunity_GetLinkFilterHashes_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
+    }
+}
+impl ::steam_vent_proto_common::RpcMessage
+for CCommunity_GetLinkFilterListVersion_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 CCommunity_GetLinkFilterListVersion_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
+    }
+}
+///
+struct CommunityLinkFilter {}
+impl ::steam_vent_proto_common::RpcService for CommunityLinkFilter {
+    const SERVICE_NAME: &'static str = "CommunityLinkFilter";
+}
+impl ::steam_vent_proto_common::RpcMethod
+for CCommunity_GetLinkFilterHashPrefixes_Request {
+    const METHOD_NAME: &'static str = "CommunityLinkFilter.GetLinkFilterHashPrefixes#1";
+    type Response = CCommunity_GetLinkFilterHashPrefixes_Response;
+}
+impl ::steam_vent_proto_common::RpcMethod for CCommunity_GetLinkFilterHashes_Request {
+    const METHOD_NAME: &'static str = "CommunityLinkFilter.GetLinkFilterHashes#1";
+    type Response = CCommunity_GetLinkFilterHashes_Response;
+}
+impl ::steam_vent_proto_common::RpcMethod
+for CCommunity_GetLinkFilterListVersion_Request {
+    const METHOD_NAME: &'static str = "CommunityLinkFilter.GetLinkFilterListVersion#1";
+    type Response = CCommunity_GetLinkFilterListVersion_Response;
+}

steam/src/generated/steammessages_lobbymatchmaking_steamclient.rs

@@ -0,0 +1,540 @@
+// 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_lobbymatchmaking.steamclient.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:LobbyMatchmakingLegacy_GetLobbyStatus_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct LobbyMatchmakingLegacy_GetLobbyStatus_Request {
+    // message fields
+    // @@protoc_insertion_point(field:LobbyMatchmakingLegacy_GetLobbyStatus_Request.app_id)
+    pub app_id: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:LobbyMatchmakingLegacy_GetLobbyStatus_Request.steamid_lobby)
+    pub steamid_lobby: ::std::option::Option<u64>,
+    // @@protoc_insertion_point(field:LobbyMatchmakingLegacy_GetLobbyStatus_Request.claim_ownership)
+    pub claim_ownership: ::std::option::Option<bool>,
+    // @@protoc_insertion_point(field:LobbyMatchmakingLegacy_GetLobbyStatus_Request.claim_membership)
+    pub claim_membership: ::std::option::Option<bool>,
+    // @@protoc_insertion_point(field:LobbyMatchmakingLegacy_GetLobbyStatus_Request.version_num)
+    pub version_num: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:LobbyMatchmakingLegacy_GetLobbyStatus_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a LobbyMatchmakingLegacy_GetLobbyStatus_Request {
+    fn default() -> &'a LobbyMatchmakingLegacy_GetLobbyStatus_Request {
+        <LobbyMatchmakingLegacy_GetLobbyStatus_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl LobbyMatchmakingLegacy_GetLobbyStatus_Request {
+    pub fn new() -> LobbyMatchmakingLegacy_GetLobbyStatus_Request {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 app_id = 1;
+
+    pub fn app_id(&self) -> u32 {
+        self.app_id.unwrap_or(0)
+    }
+
+    pub fn clear_app_id(&mut self) {
+        self.app_id = ::std::option::Option::None;
+    }
+
+    pub fn has_app_id(&self) -> bool {
+        self.app_id.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_app_id(&mut self, v: u32) {
+        self.app_id = ::std::option::Option::Some(v);
+    }
+
+    // optional fixed64 steamid_lobby = 2;
+
+    pub fn steamid_lobby(&self) -> u64 {
+        self.steamid_lobby.unwrap_or(0)
+    }
+
+    pub fn clear_steamid_lobby(&mut self) {
+        self.steamid_lobby = ::std::option::Option::None;
+    }
+
+    pub fn has_steamid_lobby(&self) -> bool {
+        self.steamid_lobby.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_steamid_lobby(&mut self, v: u64) {
+        self.steamid_lobby = ::std::option::Option::Some(v);
+    }
+
+    // optional bool claim_ownership = 3;
+
+    pub fn claim_ownership(&self) -> bool {
+        self.claim_ownership.unwrap_or(false)
+    }
+
+    pub fn clear_claim_ownership(&mut self) {
+        self.claim_ownership = ::std::option::Option::None;
+    }
+
+    pub fn has_claim_ownership(&self) -> bool {
+        self.claim_ownership.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_claim_ownership(&mut self, v: bool) {
+        self.claim_ownership = ::std::option::Option::Some(v);
+    }
+
+    // optional bool claim_membership = 4;
+
+    pub fn claim_membership(&self) -> bool {
+        self.claim_membership.unwrap_or(false)
+    }
+
+    pub fn clear_claim_membership(&mut self) {
+        self.claim_membership = ::std::option::Option::None;
+    }
+
+    pub fn has_claim_membership(&self) -> bool {
+        self.claim_membership.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_claim_membership(&mut self, v: bool) {
+        self.claim_membership = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 version_num = 5;
+
+    pub fn version_num(&self) -> u32 {
+        self.version_num.unwrap_or(0)
+    }
+
+    pub fn clear_version_num(&mut self) {
+        self.version_num = ::std::option::Option::None;
+    }
+
+    pub fn has_version_num(&self) -> bool {
+        self.version_num.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_version_num(&mut self, v: u32) {
+        self.version_num = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for LobbyMatchmakingLegacy_GetLobbyStatus_Request {
+    const NAME: &'static str = "LobbyMatchmakingLegacy_GetLobbyStatus_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.app_id = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                17 => {
+                    self.steamid_lobby = ::std::option::Option::Some(is.read_fixed64()?);
+                },
+                24 => {
+                    self.claim_ownership = ::std::option::Option::Some(is.read_bool()?);
+                },
+                32 => {
+                    self.claim_membership = ::std::option::Option::Some(is.read_bool()?);
+                },
+                40 => {
+                    self.version_num = ::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.app_id {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.steamid_lobby {
+            my_size += 1 + 8;
+        }
+        if let Some(v) = self.claim_ownership {
+            my_size += 1 + 1;
+        }
+        if let Some(v) = self.claim_membership {
+            my_size += 1 + 1;
+        }
+        if let Some(v) = self.version_num {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
+        }
+        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        if let Some(v) = self.app_id {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.steamid_lobby {
+            os.write_fixed64(2, v)?;
+        }
+        if let Some(v) = self.claim_ownership {
+            os.write_bool(3, v)?;
+        }
+        if let Some(v) = self.claim_membership {
+            os.write_bool(4, v)?;
+        }
+        if let Some(v) = self.version_num {
+            os.write_uint32(5, v)?;
+        }
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> LobbyMatchmakingLegacy_GetLobbyStatus_Request {
+        LobbyMatchmakingLegacy_GetLobbyStatus_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.app_id = ::std::option::Option::None;
+        self.steamid_lobby = ::std::option::Option::None;
+        self.claim_ownership = ::std::option::Option::None;
+        self.claim_membership = ::std::option::Option::None;
+        self.version_num = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static LobbyMatchmakingLegacy_GetLobbyStatus_Request {
+        static instance: LobbyMatchmakingLegacy_GetLobbyStatus_Request = LobbyMatchmakingLegacy_GetLobbyStatus_Request {
+            app_id: ::std::option::Option::None,
+            steamid_lobby: ::std::option::Option::None,
+            claim_ownership: ::std::option::Option::None,
+            claim_membership: ::std::option::Option::None,
+            version_num: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:LobbyMatchmakingLegacy_GetLobbyStatus_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct LobbyMatchmakingLegacy_GetLobbyStatus_Response {
+    // message fields
+    // @@protoc_insertion_point(field:LobbyMatchmakingLegacy_GetLobbyStatus_Response.app_id)
+    pub app_id: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:LobbyMatchmakingLegacy_GetLobbyStatus_Response.steamid_lobby)
+    pub steamid_lobby: ::std::option::Option<u64>,
+    // @@protoc_insertion_point(field:LobbyMatchmakingLegacy_GetLobbyStatus_Response.lobby_status)
+    pub lobby_status: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<ELobbyStatus>>,
+    // special fields
+    // @@protoc_insertion_point(special_field:LobbyMatchmakingLegacy_GetLobbyStatus_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a LobbyMatchmakingLegacy_GetLobbyStatus_Response {
+    fn default() -> &'a LobbyMatchmakingLegacy_GetLobbyStatus_Response {
+        <LobbyMatchmakingLegacy_GetLobbyStatus_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl LobbyMatchmakingLegacy_GetLobbyStatus_Response {
+    pub fn new() -> LobbyMatchmakingLegacy_GetLobbyStatus_Response {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 app_id = 1;
+
+    pub fn app_id(&self) -> u32 {
+        self.app_id.unwrap_or(0)
+    }
+
+    pub fn clear_app_id(&mut self) {
+        self.app_id = ::std::option::Option::None;
+    }
+
+    pub fn has_app_id(&self) -> bool {
+        self.app_id.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_app_id(&mut self, v: u32) {
+        self.app_id = ::std::option::Option::Some(v);
+    }
+
+    // optional fixed64 steamid_lobby = 2;
+
+    pub fn steamid_lobby(&self) -> u64 {
+        self.steamid_lobby.unwrap_or(0)
+    }
+
+    pub fn clear_steamid_lobby(&mut self) {
+        self.steamid_lobby = ::std::option::Option::None;
+    }
+
+    pub fn has_steamid_lobby(&self) -> bool {
+        self.steamid_lobby.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_steamid_lobby(&mut self, v: u64) {
+        self.steamid_lobby = ::std::option::Option::Some(v);
+    }
+
+    // optional .ELobbyStatus lobby_status = 3;
+
+    pub fn lobby_status(&self) -> ELobbyStatus {
+        match self.lobby_status {
+            Some(e) => e.enum_value_or(ELobbyStatus::k_ELobbyStatusInvalid),
+            None => ELobbyStatus::k_ELobbyStatusInvalid,
+        }
+    }
+
+    pub fn clear_lobby_status(&mut self) {
+        self.lobby_status = ::std::option::Option::None;
+    }
+
+    pub fn has_lobby_status(&self) -> bool {
+        self.lobby_status.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_lobby_status(&mut self, v: ELobbyStatus) {
+        self.lobby_status = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for LobbyMatchmakingLegacy_GetLobbyStatus_Response {
+    const NAME: &'static str = "LobbyMatchmakingLegacy_GetLobbyStatus_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.app_id = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                17 => {
+                    self.steamid_lobby = ::std::option::Option::Some(is.read_fixed64()?);
+                },
+                24 => {
+                    self.lobby_status = ::std::option::Option::Some(is.read_enum_or_unknown()?);
+                },
+                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.app_id {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.steamid_lobby {
+            my_size += 1 + 8;
+        }
+        if let Some(v) = self.lobby_status {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v.value());
+        }
+        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        if let Some(v) = self.app_id {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.steamid_lobby {
+            os.write_fixed64(2, v)?;
+        }
+        if let Some(v) = self.lobby_status {
+            os.write_enum(3, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&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() -> LobbyMatchmakingLegacy_GetLobbyStatus_Response {
+        LobbyMatchmakingLegacy_GetLobbyStatus_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.app_id = ::std::option::Option::None;
+        self.steamid_lobby = ::std::option::Option::None;
+        self.lobby_status = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static LobbyMatchmakingLegacy_GetLobbyStatus_Response {
+        static instance: LobbyMatchmakingLegacy_GetLobbyStatus_Response = LobbyMatchmakingLegacy_GetLobbyStatus_Response {
+            app_id: ::std::option::Option::None,
+            steamid_lobby: ::std::option::Option::None,
+            lobby_status: ::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:ELobbyStatus)
+pub enum ELobbyStatus {
+    // @@protoc_insertion_point(enum_value:ELobbyStatus.k_ELobbyStatusInvalid)
+    k_ELobbyStatusInvalid = 0,
+    // @@protoc_insertion_point(enum_value:ELobbyStatus.k_ELobbyStatusExists)
+    k_ELobbyStatusExists = 1,
+    // @@protoc_insertion_point(enum_value:ELobbyStatus.k_ELobbyStatusDoesNotExist)
+    k_ELobbyStatusDoesNotExist = 2,
+    // @@protoc_insertion_point(enum_value:ELobbyStatus.k_ELobbyStatusNotAMember)
+    k_ELobbyStatusNotAMember = 3,
+}
+
+impl ::steam_vent_proto_common::protobuf::Enum for ELobbyStatus {
+    const NAME: &'static str = "ELobbyStatus";
+
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<ELobbyStatus> {
+        match value {
+            0 => ::std::option::Option::Some(ELobbyStatus::k_ELobbyStatusInvalid),
+            1 => ::std::option::Option::Some(ELobbyStatus::k_ELobbyStatusExists),
+            2 => ::std::option::Option::Some(ELobbyStatus::k_ELobbyStatusDoesNotExist),
+            3 => ::std::option::Option::Some(ELobbyStatus::k_ELobbyStatusNotAMember),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn from_str(str: &str) -> ::std::option::Option<ELobbyStatus> {
+        match str {
+            "k_ELobbyStatusInvalid" => ::std::option::Option::Some(ELobbyStatus::k_ELobbyStatusInvalid),
+            "k_ELobbyStatusExists" => ::std::option::Option::Some(ELobbyStatus::k_ELobbyStatusExists),
+            "k_ELobbyStatusDoesNotExist" => ::std::option::Option::Some(ELobbyStatus::k_ELobbyStatusDoesNotExist),
+            "k_ELobbyStatusNotAMember" => ::std::option::Option::Some(ELobbyStatus::k_ELobbyStatusNotAMember),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    const VALUES: &'static [ELobbyStatus] = &[
+        ELobbyStatus::k_ELobbyStatusInvalid,
+        ELobbyStatus::k_ELobbyStatusExists,
+        ELobbyStatus::k_ELobbyStatusDoesNotExist,
+        ELobbyStatus::k_ELobbyStatusNotAMember,
+    ];
+}
+
+impl ::std::default::Default for ELobbyStatus {
+    fn default() -> Self {
+        ELobbyStatus::k_ELobbyStatusInvalid
+    }
+}
+
+
+
+const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;
+
+#[allow(unused_imports)]
+use crate::steammessages_base::*;
+#[allow(unused_imports)]
+use crate::steammessages_unified_base_steamclient::*;
+impl ::steam_vent_proto_common::RpcMessage
+for LobbyMatchmakingLegacy_GetLobbyStatus_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 LobbyMatchmakingLegacy_GetLobbyStatus_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
+    }
+}
+///
+struct LobbyMatchmakingLegacy {}
+impl ::steam_vent_proto_common::RpcService for LobbyMatchmakingLegacy {
+    const SERVICE_NAME: &'static str = "LobbyMatchmakingLegacy";
+}
+impl ::steam_vent_proto_common::RpcMethod
+for LobbyMatchmakingLegacy_GetLobbyStatus_Request {
+    const METHOD_NAME: &'static str = "LobbyMatchmakingLegacy.GetLobbyStatus#1";
+    type Response = LobbyMatchmakingLegacy_GetLobbyStatus_Response;
+}

steam/src/generated/steammessages_market_steamclient.rs

@@ -0,0 +1,497 @@
+// 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_market.steamclient.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:CEconMarket_IsMarketplaceAllowed_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CEconMarket_IsMarketplaceAllowed_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CEconMarket_IsMarketplaceAllowed_Request.webcookie)
+    pub webcookie: ::std::option::Option<::std::string::String>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CEconMarket_IsMarketplaceAllowed_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CEconMarket_IsMarketplaceAllowed_Request {
+    fn default() -> &'a CEconMarket_IsMarketplaceAllowed_Request {
+        <CEconMarket_IsMarketplaceAllowed_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CEconMarket_IsMarketplaceAllowed_Request {
+    pub fn new() -> CEconMarket_IsMarketplaceAllowed_Request {
+        ::std::default::Default::default()
+    }
+
+    // optional string webcookie = 1;
+
+    pub fn webcookie(&self) -> &str {
+        match self.webcookie.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_webcookie(&mut self) {
+        self.webcookie = ::std::option::Option::None;
+    }
+
+    pub fn has_webcookie(&self) -> bool {
+        self.webcookie.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_webcookie(&mut self, v: ::std::string::String) {
+        self.webcookie = ::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_webcookie(&mut self) -> &mut ::std::string::String {
+        if self.webcookie.is_none() {
+            self.webcookie = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.webcookie.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_webcookie(&mut self) -> ::std::string::String {
+        self.webcookie.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CEconMarket_IsMarketplaceAllowed_Request {
+    const NAME: &'static str = "CEconMarket_IsMarketplaceAllowed_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.webcookie = ::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.webcookie.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.webcookie.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() -> CEconMarket_IsMarketplaceAllowed_Request {
+        CEconMarket_IsMarketplaceAllowed_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.webcookie = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CEconMarket_IsMarketplaceAllowed_Request {
+        static instance: CEconMarket_IsMarketplaceAllowed_Request = CEconMarket_IsMarketplaceAllowed_Request {
+            webcookie: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CEconMarket_IsMarketplaceAllowed_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CEconMarket_IsMarketplaceAllowed_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CEconMarket_IsMarketplaceAllowed_Response.allowed)
+    pub allowed: ::std::option::Option<bool>,
+    // @@protoc_insertion_point(field:CEconMarket_IsMarketplaceAllowed_Response.reason)
+    pub reason: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CEconMarket_IsMarketplaceAllowed_Response.allowed_at_time)
+    pub allowed_at_time: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CEconMarket_IsMarketplaceAllowed_Response.steamguard_required_days)
+    pub steamguard_required_days: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CEconMarket_IsMarketplaceAllowed_Response.forms_requested)
+    pub forms_requested: ::std::option::Option<bool>,
+    // @@protoc_insertion_point(field:CEconMarket_IsMarketplaceAllowed_Response.forms_require_verification)
+    pub forms_require_verification: ::std::option::Option<bool>,
+    // @@protoc_insertion_point(field:CEconMarket_IsMarketplaceAllowed_Response.new_device_cooldown_days)
+    pub new_device_cooldown_days: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CEconMarket_IsMarketplaceAllowed_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CEconMarket_IsMarketplaceAllowed_Response {
+    fn default() -> &'a CEconMarket_IsMarketplaceAllowed_Response {
+        <CEconMarket_IsMarketplaceAllowed_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CEconMarket_IsMarketplaceAllowed_Response {
+    pub fn new() -> CEconMarket_IsMarketplaceAllowed_Response {
+        ::std::default::Default::default()
+    }
+
+    // optional bool allowed = 1;
+
+    pub fn allowed(&self) -> bool {
+        self.allowed.unwrap_or(false)
+    }
+
+    pub fn clear_allowed(&mut self) {
+        self.allowed = ::std::option::Option::None;
+    }
+
+    pub fn has_allowed(&self) -> bool {
+        self.allowed.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_allowed(&mut self, v: bool) {
+        self.allowed = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 reason = 2;
+
+    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);
+    }
+
+    // optional uint32 allowed_at_time = 3;
+
+    pub fn allowed_at_time(&self) -> u32 {
+        self.allowed_at_time.unwrap_or(0)
+    }
+
+    pub fn clear_allowed_at_time(&mut self) {
+        self.allowed_at_time = ::std::option::Option::None;
+    }
+
+    pub fn has_allowed_at_time(&self) -> bool {
+        self.allowed_at_time.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_allowed_at_time(&mut self, v: u32) {
+        self.allowed_at_time = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 steamguard_required_days = 4;
+
+    pub fn steamguard_required_days(&self) -> u32 {
+        self.steamguard_required_days.unwrap_or(0)
+    }
+
+    pub fn clear_steamguard_required_days(&mut self) {
+        self.steamguard_required_days = ::std::option::Option::None;
+    }
+
+    pub fn has_steamguard_required_days(&self) -> bool {
+        self.steamguard_required_days.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_steamguard_required_days(&mut self, v: u32) {
+        self.steamguard_required_days = ::std::option::Option::Some(v);
+    }
+
+    // optional bool forms_requested = 7;
+
+    pub fn forms_requested(&self) -> bool {
+        self.forms_requested.unwrap_or(false)
+    }
+
+    pub fn clear_forms_requested(&mut self) {
+        self.forms_requested = ::std::option::Option::None;
+    }
+
+    pub fn has_forms_requested(&self) -> bool {
+        self.forms_requested.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_forms_requested(&mut self, v: bool) {
+        self.forms_requested = ::std::option::Option::Some(v);
+    }
+
+    // optional bool forms_require_verification = 8;
+
+    pub fn forms_require_verification(&self) -> bool {
+        self.forms_require_verification.unwrap_or(false)
+    }
+
+    pub fn clear_forms_require_verification(&mut self) {
+        self.forms_require_verification = ::std::option::Option::None;
+    }
+
+    pub fn has_forms_require_verification(&self) -> bool {
+        self.forms_require_verification.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_forms_require_verification(&mut self, v: bool) {
+        self.forms_require_verification = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 new_device_cooldown_days = 9;
+
+    pub fn new_device_cooldown_days(&self) -> u32 {
+        self.new_device_cooldown_days.unwrap_or(0)
+    }
+
+    pub fn clear_new_device_cooldown_days(&mut self) {
+        self.new_device_cooldown_days = ::std::option::Option::None;
+    }
+
+    pub fn has_new_device_cooldown_days(&self) -> bool {
+        self.new_device_cooldown_days.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_new_device_cooldown_days(&mut self, v: u32) {
+        self.new_device_cooldown_days = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CEconMarket_IsMarketplaceAllowed_Response {
+    const NAME: &'static str = "CEconMarket_IsMarketplaceAllowed_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.allowed = ::std::option::Option::Some(is.read_bool()?);
+                },
+                16 => {
+                    self.reason = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                24 => {
+                    self.allowed_at_time = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                32 => {
+                    self.steamguard_required_days = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                56 => {
+                    self.forms_requested = ::std::option::Option::Some(is.read_bool()?);
+                },
+                64 => {
+                    self.forms_require_verification = ::std::option::Option::Some(is.read_bool()?);
+                },
+                72 => {
+                    self.new_device_cooldown_days = ::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.allowed {
+            my_size += 1 + 1;
+        }
+        if let Some(v) = self.reason {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
+        }
+        if let Some(v) = self.allowed_at_time {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
+        }
+        if let Some(v) = self.steamguard_required_days {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
+        }
+        if let Some(v) = self.forms_requested {
+            my_size += 1 + 1;
+        }
+        if let Some(v) = self.forms_require_verification {
+            my_size += 1 + 1;
+        }
+        if let Some(v) = self.new_device_cooldown_days {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
+        }
+        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        if let Some(v) = self.allowed {
+            os.write_bool(1, v)?;
+        }
+        if let Some(v) = self.reason {
+            os.write_uint32(2, v)?;
+        }
+        if let Some(v) = self.allowed_at_time {
+            os.write_uint32(3, v)?;
+        }
+        if let Some(v) = self.steamguard_required_days {
+            os.write_uint32(4, v)?;
+        }
+        if let Some(v) = self.forms_requested {
+            os.write_bool(7, v)?;
+        }
+        if let Some(v) = self.forms_require_verification {
+            os.write_bool(8, v)?;
+        }
+        if let Some(v) = self.new_device_cooldown_days {
+            os.write_uint32(9, v)?;
+        }
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> CEconMarket_IsMarketplaceAllowed_Response {
+        CEconMarket_IsMarketplaceAllowed_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.allowed = ::std::option::Option::None;
+        self.reason = ::std::option::Option::None;
+        self.allowed_at_time = ::std::option::Option::None;
+        self.steamguard_required_days = ::std::option::Option::None;
+        self.forms_requested = ::std::option::Option::None;
+        self.forms_require_verification = ::std::option::Option::None;
+        self.new_device_cooldown_days = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CEconMarket_IsMarketplaceAllowed_Response {
+        static instance: CEconMarket_IsMarketplaceAllowed_Response = CEconMarket_IsMarketplaceAllowed_Response {
+            allowed: ::std::option::Option::None,
+            reason: ::std::option::Option::None,
+            allowed_at_time: ::std::option::Option::None,
+            steamguard_required_days: ::std::option::Option::None,
+            forms_requested: ::std::option::Option::None,
+            forms_require_verification: ::std::option::Option::None,
+            new_device_cooldown_days: ::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_base::*;
+#[allow(unused_imports)]
+use crate::steammessages_unified_base_steamclient::*;
+impl ::steam_vent_proto_common::RpcMessage for CEconMarket_IsMarketplaceAllowed_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 CEconMarket_IsMarketplaceAllowed_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
+    }
+}
+///
+struct EconMarket {}
+impl ::steam_vent_proto_common::RpcService for EconMarket {
+    const SERVICE_NAME: &'static str = "EconMarket";
+}
+impl ::steam_vent_proto_common::RpcMethod for CEconMarket_IsMarketplaceAllowed_Request {
+    const METHOD_NAME: &'static str = "EconMarket.IsMarketplaceAllowed#1";
+    type Response = CEconMarket_IsMarketplaceAllowed_Response;
+}

steam/src/generated/steammessages_offline_steamclient.rs

@@ -0,0 +1,755 @@
+// 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_offline.steamclient.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:COffline_GetOfflineLogonTicket_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct COffline_GetOfflineLogonTicket_Request {
+    // message fields
+    // @@protoc_insertion_point(field:COffline_GetOfflineLogonTicket_Request.priority)
+    pub priority: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:COffline_GetOfflineLogonTicket_Request.perform_encryption)
+    pub perform_encryption: ::std::option::Option<bool>,
+    // special fields
+    // @@protoc_insertion_point(special_field:COffline_GetOfflineLogonTicket_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a COffline_GetOfflineLogonTicket_Request {
+    fn default() -> &'a COffline_GetOfflineLogonTicket_Request {
+        <COffline_GetOfflineLogonTicket_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl COffline_GetOfflineLogonTicket_Request {
+    pub fn new() -> COffline_GetOfflineLogonTicket_Request {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 priority = 1;
+
+    pub fn priority(&self) -> u32 {
+        self.priority.unwrap_or(0)
+    }
+
+    pub fn clear_priority(&mut self) {
+        self.priority = ::std::option::Option::None;
+    }
+
+    pub fn has_priority(&self) -> bool {
+        self.priority.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_priority(&mut self, v: u32) {
+        self.priority = ::std::option::Option::Some(v);
+    }
+
+    // optional bool perform_encryption = 2;
+
+    pub fn perform_encryption(&self) -> bool {
+        self.perform_encryption.unwrap_or(false)
+    }
+
+    pub fn clear_perform_encryption(&mut self) {
+        self.perform_encryption = ::std::option::Option::None;
+    }
+
+    pub fn has_perform_encryption(&self) -> bool {
+        self.perform_encryption.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_perform_encryption(&mut self, v: bool) {
+        self.perform_encryption = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for COffline_GetOfflineLogonTicket_Request {
+    const NAME: &'static str = "COffline_GetOfflineLogonTicket_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.priority = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                16 => {
+                    self.perform_encryption = ::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.priority {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.perform_encryption {
+            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.priority {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.perform_encryption {
+            os.write_bool(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() -> COffline_GetOfflineLogonTicket_Request {
+        COffline_GetOfflineLogonTicket_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.priority = ::std::option::Option::None;
+        self.perform_encryption = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static COffline_GetOfflineLogonTicket_Request {
+        static instance: COffline_GetOfflineLogonTicket_Request = COffline_GetOfflineLogonTicket_Request {
+            priority: ::std::option::Option::None,
+            perform_encryption: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:COffline_GetOfflineLogonTicket_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct COffline_GetOfflineLogonTicket_Response {
+    // message fields
+    // @@protoc_insertion_point(field:COffline_GetOfflineLogonTicket_Response.serialized_ticket)
+    pub serialized_ticket: ::std::option::Option<::std::vec::Vec<u8>>,
+    // @@protoc_insertion_point(field:COffline_GetOfflineLogonTicket_Response.signature)
+    pub signature: ::std::option::Option<::std::vec::Vec<u8>>,
+    // @@protoc_insertion_point(field:COffline_GetOfflineLogonTicket_Response.encrypted_ticket)
+    pub encrypted_ticket: ::steam_vent_proto_common::protobuf::MessageField<super::offline_ticket::Offline_Ticket>,
+    // special fields
+    // @@protoc_insertion_point(special_field:COffline_GetOfflineLogonTicket_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a COffline_GetOfflineLogonTicket_Response {
+    fn default() -> &'a COffline_GetOfflineLogonTicket_Response {
+        <COffline_GetOfflineLogonTicket_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl COffline_GetOfflineLogonTicket_Response {
+    pub fn new() -> COffline_GetOfflineLogonTicket_Response {
+        ::std::default::Default::default()
+    }
+
+    // optional bytes serialized_ticket = 1;
+
+    pub fn serialized_ticket(&self) -> &[u8] {
+        match self.serialized_ticket.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_serialized_ticket(&mut self) {
+        self.serialized_ticket = ::std::option::Option::None;
+    }
+
+    pub fn has_serialized_ticket(&self) -> bool {
+        self.serialized_ticket.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_serialized_ticket(&mut self, v: ::std::vec::Vec<u8>) {
+        self.serialized_ticket = ::std::option::Option::Some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_serialized_ticket(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.serialized_ticket.is_none() {
+            self.serialized_ticket = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.serialized_ticket.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_serialized_ticket(&mut self) -> ::std::vec::Vec<u8> {
+        self.serialized_ticket.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    // optional bytes signature = 2;
+
+    pub fn signature(&self) -> &[u8] {
+        match self.signature.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_signature(&mut self) {
+        self.signature = ::std::option::Option::None;
+    }
+
+    pub fn has_signature(&self) -> bool {
+        self.signature.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_signature(&mut self, v: ::std::vec::Vec<u8>) {
+        self.signature = ::std::option::Option::Some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_signature(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.signature.is_none() {
+            self.signature = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.signature.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_signature(&mut self) -> ::std::vec::Vec<u8> {
+        self.signature.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for COffline_GetOfflineLogonTicket_Response {
+    const NAME: &'static str = "COffline_GetOfflineLogonTicket_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.serialized_ticket = ::std::option::Option::Some(is.read_bytes()?);
+                },
+                18 => {
+                    self.signature = ::std::option::Option::Some(is.read_bytes()?);
+                },
+                26 => {
+                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.encrypted_ticket)?;
+                },
+                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.serialized_ticket.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(1, &v);
+        }
+        if let Some(v) = self.signature.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(2, &v);
+        }
+        if let Some(v) = self.encrypted_ticket.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.serialized_ticket.as_ref() {
+            os.write_bytes(1, v)?;
+        }
+        if let Some(v) = self.signature.as_ref() {
+            os.write_bytes(2, v)?;
+        }
+        if let Some(v) = self.encrypted_ticket.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
+        }
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> COffline_GetOfflineLogonTicket_Response {
+        COffline_GetOfflineLogonTicket_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.serialized_ticket = ::std::option::Option::None;
+        self.signature = ::std::option::Option::None;
+        self.encrypted_ticket.clear();
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static COffline_GetOfflineLogonTicket_Response {
+        static instance: COffline_GetOfflineLogonTicket_Response = COffline_GetOfflineLogonTicket_Response {
+            serialized_ticket: ::std::option::Option::None,
+            signature: ::std::option::Option::None,
+            encrypted_ticket: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:COffline_GetUnsignedOfflineLogonTicket_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct COffline_GetUnsignedOfflineLogonTicket_Request {
+    // special fields
+    // @@protoc_insertion_point(special_field:COffline_GetUnsignedOfflineLogonTicket_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a COffline_GetUnsignedOfflineLogonTicket_Request {
+    fn default() -> &'a COffline_GetUnsignedOfflineLogonTicket_Request {
+        <COffline_GetUnsignedOfflineLogonTicket_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl COffline_GetUnsignedOfflineLogonTicket_Request {
+    pub fn new() -> COffline_GetUnsignedOfflineLogonTicket_Request {
+        ::std::default::Default::default()
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for COffline_GetUnsignedOfflineLogonTicket_Request {
+    const NAME: &'static str = "COffline_GetUnsignedOfflineLogonTicket_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 {
+                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() -> COffline_GetUnsignedOfflineLogonTicket_Request {
+        COffline_GetUnsignedOfflineLogonTicket_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static COffline_GetUnsignedOfflineLogonTicket_Request {
+        static instance: COffline_GetUnsignedOfflineLogonTicket_Request = COffline_GetUnsignedOfflineLogonTicket_Request {
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:COffline_OfflineLogonTicket)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct COffline_OfflineLogonTicket {
+    // message fields
+    // @@protoc_insertion_point(field:COffline_OfflineLogonTicket.accountid)
+    pub accountid: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:COffline_OfflineLogonTicket.rtime32_creation_time)
+    pub rtime32_creation_time: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:COffline_OfflineLogonTicket.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a COffline_OfflineLogonTicket {
+    fn default() -> &'a COffline_OfflineLogonTicket {
+        <COffline_OfflineLogonTicket as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl COffline_OfflineLogonTicket {
+    pub fn new() -> COffline_OfflineLogonTicket {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 accountid = 1;
+
+    pub fn accountid(&self) -> u32 {
+        self.accountid.unwrap_or(0)
+    }
+
+    pub fn clear_accountid(&mut self) {
+        self.accountid = ::std::option::Option::None;
+    }
+
+    pub fn has_accountid(&self) -> bool {
+        self.accountid.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_accountid(&mut self, v: u32) {
+        self.accountid = ::std::option::Option::Some(v);
+    }
+
+    // optional fixed32 rtime32_creation_time = 2;
+
+    pub fn rtime32_creation_time(&self) -> u32 {
+        self.rtime32_creation_time.unwrap_or(0)
+    }
+
+    pub fn clear_rtime32_creation_time(&mut self) {
+        self.rtime32_creation_time = ::std::option::Option::None;
+    }
+
+    pub fn has_rtime32_creation_time(&self) -> bool {
+        self.rtime32_creation_time.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_rtime32_creation_time(&mut self, v: u32) {
+        self.rtime32_creation_time = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for COffline_OfflineLogonTicket {
+    const NAME: &'static str = "COffline_OfflineLogonTicket";
+
+    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.accountid = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                21 => {
+                    self.rtime32_creation_time = ::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.accountid {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.rtime32_creation_time {
+            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.accountid {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.rtime32_creation_time {
+            os.write_fixed32(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() -> COffline_OfflineLogonTicket {
+        COffline_OfflineLogonTicket::new()
+    }
+
+    fn clear(&mut self) {
+        self.accountid = ::std::option::Option::None;
+        self.rtime32_creation_time = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static COffline_OfflineLogonTicket {
+        static instance: COffline_OfflineLogonTicket = COffline_OfflineLogonTicket {
+            accountid: ::std::option::Option::None,
+            rtime32_creation_time: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:COffline_GetUnsignedOfflineLogonTicket_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct COffline_GetUnsignedOfflineLogonTicket_Response {
+    // message fields
+    // @@protoc_insertion_point(field:COffline_GetUnsignedOfflineLogonTicket_Response.ticket)
+    pub ticket: ::steam_vent_proto_common::protobuf::MessageField<COffline_OfflineLogonTicket>,
+    // special fields
+    // @@protoc_insertion_point(special_field:COffline_GetUnsignedOfflineLogonTicket_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a COffline_GetUnsignedOfflineLogonTicket_Response {
+    fn default() -> &'a COffline_GetUnsignedOfflineLogonTicket_Response {
+        <COffline_GetUnsignedOfflineLogonTicket_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl COffline_GetUnsignedOfflineLogonTicket_Response {
+    pub fn new() -> COffline_GetUnsignedOfflineLogonTicket_Response {
+        ::std::default::Default::default()
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for COffline_GetUnsignedOfflineLogonTicket_Response {
+    const NAME: &'static str = "COffline_GetUnsignedOfflineLogonTicket_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 => {
+                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.ticket)?;
+                },
+                tag => {
+                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u64 {
+        let mut my_size = 0;
+        if let Some(v) = self.ticket.as_ref() {
+            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.ticket.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, 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() -> COffline_GetUnsignedOfflineLogonTicket_Response {
+        COffline_GetUnsignedOfflineLogonTicket_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.ticket.clear();
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static COffline_GetUnsignedOfflineLogonTicket_Response {
+        static instance: COffline_GetUnsignedOfflineLogonTicket_Response = COffline_GetUnsignedOfflineLogonTicket_Response {
+            ticket: ::steam_vent_proto_common::protobuf::MessageField::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_base::*;
+#[allow(unused_imports)]
+use crate::steammessages_unified_base_steamclient::*;
+#[allow(unused_imports)]
+use crate::offline_ticket::*;
+impl ::steam_vent_proto_common::RpcMessage for COffline_GetOfflineLogonTicket_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 COffline_GetOfflineLogonTicket_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
+    }
+}
+impl ::steam_vent_proto_common::RpcMessage
+for COffline_GetUnsignedOfflineLogonTicket_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 COffline_OfflineLogonTicket {
+    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 COffline_GetUnsignedOfflineLogonTicket_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
+    }
+}
+///
+struct Offline {}
+impl ::steam_vent_proto_common::RpcService for Offline {
+    const SERVICE_NAME: &'static str = "Offline";
+}
+impl ::steam_vent_proto_common::RpcMethod for COffline_GetOfflineLogonTicket_Request {
+    const METHOD_NAME: &'static str = "Offline.GetOfflineLogonTicket#1";
+    type Response = COffline_GetOfflineLogonTicket_Response;
+}
+impl ::steam_vent_proto_common::RpcMethod
+for COffline_GetUnsignedOfflineLogonTicket_Request {
+    const METHOD_NAME: &'static str = "Offline.GetUnsignedOfflineLogonTicket#1";
+    type Response = COffline_GetUnsignedOfflineLogonTicket_Response;
+}

steam/src/generated/steammessages_remoteclient_service_steamclient.rs

@@ -0,0 +1,122 @@
+// 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_remoteclient_service.steamclient.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;
+
+
+const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;
+
+#[allow(unused_imports)]
+use crate::steammessages_base::*;
+#[allow(unused_imports)]
+use crate::steammessages_unified_base_steamclient::*;
+#[allow(unused_imports)]
+use crate::steammessages_remoteclient_service_messages::*;
+///
+struct RemoteClient {}
+impl ::steam_vent_proto_common::RpcService for RemoteClient {
+    const SERVICE_NAME: &'static str = "RemoteClient";
+}
+///
+struct RemoteClientSteamClient {}
+impl ::steam_vent_proto_common::RpcService for RemoteClientSteamClient {
+    const SERVICE_NAME: &'static str = "RemoteClientSteamClient";
+}
+impl ::steam_vent_proto_common::RpcMethod for CRemoteClient_AllocateRelayServer_Request {
+    const METHOD_NAME: &'static str = "RemoteClient.AllocateRelayServer#1";
+    type Response = CRemoteClient_AllocateRelayServer_Response;
+}
+impl ::steam_vent_proto_common::RpcMethod for CRemoteClient_AllocateSDR_Request {
+    const METHOD_NAME: &'static str = "RemoteClient.AllocateSDR#1";
+    type Response = CRemoteClient_AllocateSDR_Response;
+}
+impl ::steam_vent_proto_common::RpcMethod
+for CRemoteClient_CreateRemotePlayTogetherInvitation_Request {
+    const METHOD_NAME: &'static str = "RemoteClient.CreateRemotePlayTogetherInvitation#1";
+    type Response = CRemoteClient_CreateRemotePlayTogetherInvitation_Response;
+}
+impl ::steam_vent_proto_common::RpcMethod
+for CRemoteClient_DeleteRemotePlayTogetherInvitation_Request {
+    const METHOD_NAME: &'static str = "RemoteClient.DeleteRemotePlayTogetherInvitation#1";
+    type Response = CRemoteClient_DeleteRemotePlayTogetherInvitation_Response;
+}
+impl ::steam_vent_proto_common::RpcMethod for CRemoteClient_GetPairingInfo_Request {
+    const METHOD_NAME: &'static str = "RemoteClient.GetPairingInfo#1";
+    type Response = CRemoteClient_GetPairingInfo_Response;
+}
+impl ::steam_vent_proto_common::RpcMethod for CRemoteClient_GetRecentClients_Request {
+    const METHOD_NAME: &'static str = "RemoteClient.GetRecentClients#1";
+    type Response = CRemoteClient_GetRecentClients_Response;
+}
+impl ::steam_vent_proto_common::RpcMethod for CRemoteClient_MarkTaskComplete_Request {
+    const METHOD_NAME: &'static str = "RemoteClient.MarkTaskComplete#1";
+    type Response = CRemoteClient_MarkTaskComplete_Response;
+}
+impl ::steam_vent_proto_common::RpcMethod for CRemoteClient_Online_Notification {
+    const METHOD_NAME: &'static str = "RemoteClient.NotifyOnline#1";
+    type Response = ();
+}
+impl ::steam_vent_proto_common::RpcMethod
+for CRemoteClient_RegisterStatusUpdate_Notification {
+    const METHOD_NAME: &'static str = "RemoteClientSteamClient.NotifyRegisterStatusUpdate#1";
+    type Response = ();
+}
+impl ::steam_vent_proto_common::RpcMethod for CRemoteClient_RemotePacket_Notification {
+    const METHOD_NAME: &'static str = "RemoteClientSteamClient.NotifyRemotePacket#1";
+    type Response = ();
+}
+impl ::steam_vent_proto_common::RpcMethod for CRemoteClient_ReplyPacket_Notification {
+    const METHOD_NAME: &'static str = "RemoteClient.NotifyReplyPacket#1";
+    type Response = ();
+}
+impl ::steam_vent_proto_common::RpcMethod for CRemoteClient_SteamBroadcast_Notification {
+    const METHOD_NAME: &'static str = "RemoteClient.SendSteamBroadcastPacket#1";
+    type Response = ();
+}
+impl ::steam_vent_proto_common::RpcMethod for CRemoteClient_SteamToSteam_Notification {
+    const METHOD_NAME: &'static str = "RemoteClient.SendSteamToSteamPacket#1";
+    type Response = ();
+}
+impl ::steam_vent_proto_common::RpcMethod for CRemoteClient_TaskList_Notification {
+    const METHOD_NAME: &'static str = "RemoteClientSteamClient.NotifyTaskList#1";
+    type Response = ();
+}
+impl ::steam_vent_proto_common::RpcMethod
+for CRemoteClient_UnregisterStatusUpdate_Notification {
+    const METHOD_NAME: &'static str = "RemoteClientSteamClient.NotifyUnregisterStatusUpdate#1";
+    type Response = ();
+}
+impl ::steam_vent_proto_common::RpcMethod for CRemotePlayTogether_Notification {
+    const METHOD_NAME: &'static str = "RemoteClient.SendRemotePlayTogetherPacket#1";
+    type Response = ();
+}
+impl ::steam_vent_proto_common::RpcMethod for CRemotePlay_SessionStarted_Request {
+    const METHOD_NAME: &'static str = "RemoteClient.SendRemotePlaySessionStarted#1";
+    type Response = CRemotePlay_SessionStarted_Response;
+}
+impl ::steam_vent_proto_common::RpcMethod for CRemotePlay_SessionStopped_Notification {
+    const METHOD_NAME: &'static str = "RemoteClient.SendRemotePlaySessionStopped#1";
+    type Response = ();
+}

steam/src/generated/steammessages_secrets_steamclient.rs

@@ -0,0 +1,925 @@
+// 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_secrets.steamclient.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:CKeyEscrow_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CKeyEscrow_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CKeyEscrow_Request.rsa_oaep_sha_ticket)
+    pub rsa_oaep_sha_ticket: ::std::option::Option<::std::vec::Vec<u8>>,
+    // @@protoc_insertion_point(field:CKeyEscrow_Request.password)
+    pub password: ::std::option::Option<::std::vec::Vec<u8>>,
+    // @@protoc_insertion_point(field:CKeyEscrow_Request.usage)
+    pub usage: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<EKeyEscrowUsage>>,
+    // @@protoc_insertion_point(field:CKeyEscrow_Request.device_name)
+    pub device_name: ::std::option::Option<::std::string::String>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CKeyEscrow_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CKeyEscrow_Request {
+    fn default() -> &'a CKeyEscrow_Request {
+        <CKeyEscrow_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CKeyEscrow_Request {
+    pub fn new() -> CKeyEscrow_Request {
+        ::std::default::Default::default()
+    }
+
+    // optional bytes rsa_oaep_sha_ticket = 1;
+
+    pub fn rsa_oaep_sha_ticket(&self) -> &[u8] {
+        match self.rsa_oaep_sha_ticket.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_rsa_oaep_sha_ticket(&mut self) {
+        self.rsa_oaep_sha_ticket = ::std::option::Option::None;
+    }
+
+    pub fn has_rsa_oaep_sha_ticket(&self) -> bool {
+        self.rsa_oaep_sha_ticket.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_rsa_oaep_sha_ticket(&mut self, v: ::std::vec::Vec<u8>) {
+        self.rsa_oaep_sha_ticket = ::std::option::Option::Some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_rsa_oaep_sha_ticket(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.rsa_oaep_sha_ticket.is_none() {
+            self.rsa_oaep_sha_ticket = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.rsa_oaep_sha_ticket.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_rsa_oaep_sha_ticket(&mut self) -> ::std::vec::Vec<u8> {
+        self.rsa_oaep_sha_ticket.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    // optional bytes password = 2;
+
+    pub fn password(&self) -> &[u8] {
+        match self.password.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_password(&mut self) {
+        self.password = ::std::option::Option::None;
+    }
+
+    pub fn has_password(&self) -> bool {
+        self.password.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_password(&mut self, v: ::std::vec::Vec<u8>) {
+        self.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_password(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.password.is_none() {
+            self.password = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.password.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_password(&mut self) -> ::std::vec::Vec<u8> {
+        self.password.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    // optional .EKeyEscrowUsage usage = 3;
+
+    pub fn usage(&self) -> EKeyEscrowUsage {
+        match self.usage {
+            Some(e) => e.enum_value_or(EKeyEscrowUsage::k_EKeyEscrowUsageStreamingDevice),
+            None => EKeyEscrowUsage::k_EKeyEscrowUsageStreamingDevice,
+        }
+    }
+
+    pub fn clear_usage(&mut self) {
+        self.usage = ::std::option::Option::None;
+    }
+
+    pub fn has_usage(&self) -> bool {
+        self.usage.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_usage(&mut self, v: EKeyEscrowUsage) {
+        self.usage = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
+    }
+
+    // optional string device_name = 4;
+
+    pub fn device_name(&self) -> &str {
+        match self.device_name.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_device_name(&mut self) {
+        self.device_name = ::std::option::Option::None;
+    }
+
+    pub fn has_device_name(&self) -> bool {
+        self.device_name.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_device_name(&mut self, v: ::std::string::String) {
+        self.device_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_device_name(&mut self) -> &mut ::std::string::String {
+        if self.device_name.is_none() {
+            self.device_name = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.device_name.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_device_name(&mut self) -> ::std::string::String {
+        self.device_name.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CKeyEscrow_Request {
+    const NAME: &'static str = "CKeyEscrow_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.rsa_oaep_sha_ticket = ::std::option::Option::Some(is.read_bytes()?);
+                },
+                18 => {
+                    self.password = ::std::option::Option::Some(is.read_bytes()?);
+                },
+                24 => {
+                    self.usage = ::std::option::Option::Some(is.read_enum_or_unknown()?);
+                },
+                34 => {
+                    self.device_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.rsa_oaep_sha_ticket.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(1, &v);
+        }
+        if let Some(v) = self.password.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(2, &v);
+        }
+        if let Some(v) = self.usage {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v.value());
+        }
+        if let Some(v) = self.device_name.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.rsa_oaep_sha_ticket.as_ref() {
+            os.write_bytes(1, v)?;
+        }
+        if let Some(v) = self.password.as_ref() {
+            os.write_bytes(2, v)?;
+        }
+        if let Some(v) = self.usage {
+            os.write_enum(3, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
+        }
+        if let Some(v) = self.device_name.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() -> CKeyEscrow_Request {
+        CKeyEscrow_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.rsa_oaep_sha_ticket = ::std::option::Option::None;
+        self.password = ::std::option::Option::None;
+        self.usage = ::std::option::Option::None;
+        self.device_name = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CKeyEscrow_Request {
+        static instance: CKeyEscrow_Request = CKeyEscrow_Request {
+            rsa_oaep_sha_ticket: ::std::option::Option::None,
+            password: ::std::option::Option::None,
+            usage: ::std::option::Option::None,
+            device_name: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CKeyEscrow_Ticket)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CKeyEscrow_Ticket {
+    // message fields
+    // @@protoc_insertion_point(field:CKeyEscrow_Ticket.password)
+    pub password: ::std::option::Option<::std::vec::Vec<u8>>,
+    // @@protoc_insertion_point(field:CKeyEscrow_Ticket.identifier)
+    pub identifier: ::std::option::Option<u64>,
+    // @@protoc_insertion_point(field:CKeyEscrow_Ticket.payload)
+    pub payload: ::std::option::Option<::std::vec::Vec<u8>>,
+    // @@protoc_insertion_point(field:CKeyEscrow_Ticket.timestamp)
+    pub timestamp: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CKeyEscrow_Ticket.usage)
+    pub usage: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<EKeyEscrowUsage>>,
+    // @@protoc_insertion_point(field:CKeyEscrow_Ticket.device_name)
+    pub device_name: ::std::option::Option<::std::string::String>,
+    // @@protoc_insertion_point(field:CKeyEscrow_Ticket.device_model)
+    pub device_model: ::std::option::Option<::std::string::String>,
+    // @@protoc_insertion_point(field:CKeyEscrow_Ticket.device_serial)
+    pub device_serial: ::std::option::Option<::std::string::String>,
+    // @@protoc_insertion_point(field:CKeyEscrow_Ticket.device_provisioning_id)
+    pub device_provisioning_id: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CKeyEscrow_Ticket.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CKeyEscrow_Ticket {
+    fn default() -> &'a CKeyEscrow_Ticket {
+        <CKeyEscrow_Ticket as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CKeyEscrow_Ticket {
+    pub fn new() -> CKeyEscrow_Ticket {
+        ::std::default::Default::default()
+    }
+
+    // optional bytes password = 1;
+
+    pub fn password(&self) -> &[u8] {
+        match self.password.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_password(&mut self) {
+        self.password = ::std::option::Option::None;
+    }
+
+    pub fn has_password(&self) -> bool {
+        self.password.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_password(&mut self, v: ::std::vec::Vec<u8>) {
+        self.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_password(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.password.is_none() {
+            self.password = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.password.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_password(&mut self) -> ::std::vec::Vec<u8> {
+        self.password.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    // optional uint64 identifier = 2;
+
+    pub fn identifier(&self) -> u64 {
+        self.identifier.unwrap_or(0)
+    }
+
+    pub fn clear_identifier(&mut self) {
+        self.identifier = ::std::option::Option::None;
+    }
+
+    pub fn has_identifier(&self) -> bool {
+        self.identifier.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_identifier(&mut self, v: u64) {
+        self.identifier = ::std::option::Option::Some(v);
+    }
+
+    // optional bytes payload = 3;
+
+    pub fn payload(&self) -> &[u8] {
+        match self.payload.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_payload(&mut self) {
+        self.payload = ::std::option::Option::None;
+    }
+
+    pub fn has_payload(&self) -> bool {
+        self.payload.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_payload(&mut self, v: ::std::vec::Vec<u8>) {
+        self.payload = ::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_payload(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.payload.is_none() {
+            self.payload = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.payload.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_payload(&mut self) -> ::std::vec::Vec<u8> {
+        self.payload.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    // optional uint32 timestamp = 4;
+
+    pub fn timestamp(&self) -> u32 {
+        self.timestamp.unwrap_or(0)
+    }
+
+    pub fn clear_timestamp(&mut self) {
+        self.timestamp = ::std::option::Option::None;
+    }
+
+    pub fn has_timestamp(&self) -> bool {
+        self.timestamp.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_timestamp(&mut self, v: u32) {
+        self.timestamp = ::std::option::Option::Some(v);
+    }
+
+    // optional .EKeyEscrowUsage usage = 5;
+
+    pub fn usage(&self) -> EKeyEscrowUsage {
+        match self.usage {
+            Some(e) => e.enum_value_or(EKeyEscrowUsage::k_EKeyEscrowUsageStreamingDevice),
+            None => EKeyEscrowUsage::k_EKeyEscrowUsageStreamingDevice,
+        }
+    }
+
+    pub fn clear_usage(&mut self) {
+        self.usage = ::std::option::Option::None;
+    }
+
+    pub fn has_usage(&self) -> bool {
+        self.usage.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_usage(&mut self, v: EKeyEscrowUsage) {
+        self.usage = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
+    }
+
+    // optional string device_name = 6;
+
+    pub fn device_name(&self) -> &str {
+        match self.device_name.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_device_name(&mut self) {
+        self.device_name = ::std::option::Option::None;
+    }
+
+    pub fn has_device_name(&self) -> bool {
+        self.device_name.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_device_name(&mut self, v: ::std::string::String) {
+        self.device_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_device_name(&mut self) -> &mut ::std::string::String {
+        if self.device_name.is_none() {
+            self.device_name = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.device_name.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_device_name(&mut self) -> ::std::string::String {
+        self.device_name.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional string device_model = 7;
+
+    pub fn device_model(&self) -> &str {
+        match self.device_model.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_device_model(&mut self) {
+        self.device_model = ::std::option::Option::None;
+    }
+
+    pub fn has_device_model(&self) -> bool {
+        self.device_model.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_device_model(&mut self, v: ::std::string::String) {
+        self.device_model = ::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_device_model(&mut self) -> &mut ::std::string::String {
+        if self.device_model.is_none() {
+            self.device_model = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.device_model.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_device_model(&mut self) -> ::std::string::String {
+        self.device_model.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional string device_serial = 8;
+
+    pub fn device_serial(&self) -> &str {
+        match self.device_serial.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_device_serial(&mut self) {
+        self.device_serial = ::std::option::Option::None;
+    }
+
+    pub fn has_device_serial(&self) -> bool {
+        self.device_serial.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_device_serial(&mut self, v: ::std::string::String) {
+        self.device_serial = ::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_device_serial(&mut self) -> &mut ::std::string::String {
+        if self.device_serial.is_none() {
+            self.device_serial = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.device_serial.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_device_serial(&mut self) -> ::std::string::String {
+        self.device_serial.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional uint32 device_provisioning_id = 9;
+
+    pub fn device_provisioning_id(&self) -> u32 {
+        self.device_provisioning_id.unwrap_or(0)
+    }
+
+    pub fn clear_device_provisioning_id(&mut self) {
+        self.device_provisioning_id = ::std::option::Option::None;
+    }
+
+    pub fn has_device_provisioning_id(&self) -> bool {
+        self.device_provisioning_id.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_device_provisioning_id(&mut self, v: u32) {
+        self.device_provisioning_id = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CKeyEscrow_Ticket {
+    const NAME: &'static str = "CKeyEscrow_Ticket";
+
+    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.password = ::std::option::Option::Some(is.read_bytes()?);
+                },
+                16 => {
+                    self.identifier = ::std::option::Option::Some(is.read_uint64()?);
+                },
+                26 => {
+                    self.payload = ::std::option::Option::Some(is.read_bytes()?);
+                },
+                32 => {
+                    self.timestamp = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                40 => {
+                    self.usage = ::std::option::Option::Some(is.read_enum_or_unknown()?);
+                },
+                50 => {
+                    self.device_name = ::std::option::Option::Some(is.read_string()?);
+                },
+                58 => {
+                    self.device_model = ::std::option::Option::Some(is.read_string()?);
+                },
+                66 => {
+                    self.device_serial = ::std::option::Option::Some(is.read_string()?);
+                },
+                72 => {
+                    self.device_provisioning_id = ::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.password.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(1, &v);
+        }
+        if let Some(v) = self.identifier {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
+        }
+        if let Some(v) = self.payload.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(3, &v);
+        }
+        if let Some(v) = self.timestamp {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
+        }
+        if let Some(v) = self.usage {
+            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v.value());
+        }
+        if let Some(v) = self.device_name.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
+        }
+        if let Some(v) = self.device_model.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
+        }
+        if let Some(v) = self.device_serial.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(8, &v);
+        }
+        if let Some(v) = self.device_provisioning_id {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
+        }
+        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        if let Some(v) = self.password.as_ref() {
+            os.write_bytes(1, v)?;
+        }
+        if let Some(v) = self.identifier {
+            os.write_uint64(2, v)?;
+        }
+        if let Some(v) = self.payload.as_ref() {
+            os.write_bytes(3, v)?;
+        }
+        if let Some(v) = self.timestamp {
+            os.write_uint32(4, v)?;
+        }
+        if let Some(v) = self.usage {
+            os.write_enum(5, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
+        }
+        if let Some(v) = self.device_name.as_ref() {
+            os.write_string(6, v)?;
+        }
+        if let Some(v) = self.device_model.as_ref() {
+            os.write_string(7, v)?;
+        }
+        if let Some(v) = self.device_serial.as_ref() {
+            os.write_string(8, v)?;
+        }
+        if let Some(v) = self.device_provisioning_id {
+            os.write_uint32(9, v)?;
+        }
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> CKeyEscrow_Ticket {
+        CKeyEscrow_Ticket::new()
+    }
+
+    fn clear(&mut self) {
+        self.password = ::std::option::Option::None;
+        self.identifier = ::std::option::Option::None;
+        self.payload = ::std::option::Option::None;
+        self.timestamp = ::std::option::Option::None;
+        self.usage = ::std::option::Option::None;
+        self.device_name = ::std::option::Option::None;
+        self.device_model = ::std::option::Option::None;
+        self.device_serial = ::std::option::Option::None;
+        self.device_provisioning_id = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CKeyEscrow_Ticket {
+        static instance: CKeyEscrow_Ticket = CKeyEscrow_Ticket {
+            password: ::std::option::Option::None,
+            identifier: ::std::option::Option::None,
+            payload: ::std::option::Option::None,
+            timestamp: ::std::option::Option::None,
+            usage: ::std::option::Option::None,
+            device_name: ::std::option::Option::None,
+            device_model: ::std::option::Option::None,
+            device_serial: ::std::option::Option::None,
+            device_provisioning_id: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CKeyEscrow_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CKeyEscrow_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CKeyEscrow_Response.ticket)
+    pub ticket: ::steam_vent_proto_common::protobuf::MessageField<CKeyEscrow_Ticket>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CKeyEscrow_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CKeyEscrow_Response {
+    fn default() -> &'a CKeyEscrow_Response {
+        <CKeyEscrow_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CKeyEscrow_Response {
+    pub fn new() -> CKeyEscrow_Response {
+        ::std::default::Default::default()
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CKeyEscrow_Response {
+    const NAME: &'static str = "CKeyEscrow_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 => {
+                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.ticket)?;
+                },
+                tag => {
+                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u64 {
+        let mut my_size = 0;
+        if let Some(v) = self.ticket.as_ref() {
+            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.ticket.as_ref() {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, 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() -> CKeyEscrow_Response {
+        CKeyEscrow_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.ticket.clear();
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CKeyEscrow_Response {
+        static instance: CKeyEscrow_Response = CKeyEscrow_Response {
+            ticket: ::steam_vent_proto_common::protobuf::MessageField::none(),
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
+// @@protoc_insertion_point(enum:EKeyEscrowUsage)
+pub enum EKeyEscrowUsage {
+    // @@protoc_insertion_point(enum_value:EKeyEscrowUsage.k_EKeyEscrowUsageStreamingDevice)
+    k_EKeyEscrowUsageStreamingDevice = 0,
+}
+
+impl ::steam_vent_proto_common::protobuf::Enum for EKeyEscrowUsage {
+    const NAME: &'static str = "EKeyEscrowUsage";
+
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<EKeyEscrowUsage> {
+        match value {
+            0 => ::std::option::Option::Some(EKeyEscrowUsage::k_EKeyEscrowUsageStreamingDevice),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn from_str(str: &str) -> ::std::option::Option<EKeyEscrowUsage> {
+        match str {
+            "k_EKeyEscrowUsageStreamingDevice" => ::std::option::Option::Some(EKeyEscrowUsage::k_EKeyEscrowUsageStreamingDevice),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    const VALUES: &'static [EKeyEscrowUsage] = &[
+        EKeyEscrowUsage::k_EKeyEscrowUsageStreamingDevice,
+    ];
+}
+
+impl ::std::default::Default for EKeyEscrowUsage {
+    fn default() -> Self {
+        EKeyEscrowUsage::k_EKeyEscrowUsageStreamingDevice
+    }
+}
+
+
+
+const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;
+
+#[allow(unused_imports)]
+use crate::steammessages_base::*;
+#[allow(unused_imports)]
+use crate::steammessages_unified_base_steamclient::*;
+impl ::steam_vent_proto_common::RpcMessage for CKeyEscrow_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 CKeyEscrow_Ticket {
+    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 CKeyEscrow_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
+    }
+}
+///
+struct Secrets {}
+impl ::steam_vent_proto_common::RpcService for Secrets {
+    const SERVICE_NAME: &'static str = "Secrets";
+}
+impl ::steam_vent_proto_common::RpcMethod for CKeyEscrow_Request {
+    const METHOD_NAME: &'static str = "Secrets.KeyEscrow#1";
+    type Response = CKeyEscrow_Response;
+}

steam/src/generated/steammessages_timedtrial_steamclient.rs

@@ -0,0 +1,975 @@
+// 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_timedtrial.steamclient.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:CTimedTrial_GetTimeRemaining_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CTimedTrial_GetTimeRemaining_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CTimedTrial_GetTimeRemaining_Request.appid)
+    pub appid: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CTimedTrial_GetTimeRemaining_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CTimedTrial_GetTimeRemaining_Request {
+    fn default() -> &'a CTimedTrial_GetTimeRemaining_Request {
+        <CTimedTrial_GetTimeRemaining_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CTimedTrial_GetTimeRemaining_Request {
+    pub fn new() -> CTimedTrial_GetTimeRemaining_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);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CTimedTrial_GetTimeRemaining_Request {
+    const NAME: &'static str = "CTimedTrial_GetTimeRemaining_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()?);
+                },
+                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);
+        }
+        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)?;
+        }
+        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() -> CTimedTrial_GetTimeRemaining_Request {
+        CTimedTrial_GetTimeRemaining_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.appid = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CTimedTrial_GetTimeRemaining_Request {
+        static instance: CTimedTrial_GetTimeRemaining_Request = CTimedTrial_GetTimeRemaining_Request {
+            appid: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CTimedTrial_GetTimeRemaining_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CTimedTrial_GetTimeRemaining_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CTimedTrial_GetTimeRemaining_Response.seconds_played)
+    pub seconds_played: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CTimedTrial_GetTimeRemaining_Response.seconds_allowed)
+    pub seconds_allowed: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CTimedTrial_GetTimeRemaining_Response.packageid)
+    pub packageid: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CTimedTrial_GetTimeRemaining_Response.mastersub_appid)
+    pub mastersub_appid: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CTimedTrial_GetTimeRemaining_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CTimedTrial_GetTimeRemaining_Response {
+    fn default() -> &'a CTimedTrial_GetTimeRemaining_Response {
+        <CTimedTrial_GetTimeRemaining_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CTimedTrial_GetTimeRemaining_Response {
+    pub fn new() -> CTimedTrial_GetTimeRemaining_Response {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 seconds_played = 1;
+
+    pub fn seconds_played(&self) -> u32 {
+        self.seconds_played.unwrap_or(0)
+    }
+
+    pub fn clear_seconds_played(&mut self) {
+        self.seconds_played = ::std::option::Option::None;
+    }
+
+    pub fn has_seconds_played(&self) -> bool {
+        self.seconds_played.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_seconds_played(&mut self, v: u32) {
+        self.seconds_played = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 seconds_allowed = 2;
+
+    pub fn seconds_allowed(&self) -> u32 {
+        self.seconds_allowed.unwrap_or(0)
+    }
+
+    pub fn clear_seconds_allowed(&mut self) {
+        self.seconds_allowed = ::std::option::Option::None;
+    }
+
+    pub fn has_seconds_allowed(&self) -> bool {
+        self.seconds_allowed.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_seconds_allowed(&mut self, v: u32) {
+        self.seconds_allowed = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 packageid = 3;
+
+    pub fn packageid(&self) -> u32 {
+        self.packageid.unwrap_or(0)
+    }
+
+    pub fn clear_packageid(&mut self) {
+        self.packageid = ::std::option::Option::None;
+    }
+
+    pub fn has_packageid(&self) -> bool {
+        self.packageid.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_packageid(&mut self, v: u32) {
+        self.packageid = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 mastersub_appid = 4;
+
+    pub fn mastersub_appid(&self) -> u32 {
+        self.mastersub_appid.unwrap_or(0)
+    }
+
+    pub fn clear_mastersub_appid(&mut self) {
+        self.mastersub_appid = ::std::option::Option::None;
+    }
+
+    pub fn has_mastersub_appid(&self) -> bool {
+        self.mastersub_appid.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_mastersub_appid(&mut self, v: u32) {
+        self.mastersub_appid = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CTimedTrial_GetTimeRemaining_Response {
+    const NAME: &'static str = "CTimedTrial_GetTimeRemaining_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.seconds_played = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                16 => {
+                    self.seconds_allowed = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                24 => {
+                    self.packageid = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                32 => {
+                    self.mastersub_appid = ::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.seconds_played {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.seconds_allowed {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
+        }
+        if let Some(v) = self.packageid {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
+        }
+        if let Some(v) = self.mastersub_appid {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
+        }
+        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        if let Some(v) = self.seconds_played {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.seconds_allowed {
+            os.write_uint32(2, v)?;
+        }
+        if let Some(v) = self.packageid {
+            os.write_uint32(3, v)?;
+        }
+        if let Some(v) = self.mastersub_appid {
+            os.write_uint32(4, v)?;
+        }
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> CTimedTrial_GetTimeRemaining_Response {
+        CTimedTrial_GetTimeRemaining_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.seconds_played = ::std::option::Option::None;
+        self.seconds_allowed = ::std::option::Option::None;
+        self.packageid = ::std::option::Option::None;
+        self.mastersub_appid = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CTimedTrial_GetTimeRemaining_Response {
+        static instance: CTimedTrial_GetTimeRemaining_Response = CTimedTrial_GetTimeRemaining_Response {
+            seconds_played: ::std::option::Option::None,
+            seconds_allowed: ::std::option::Option::None,
+            packageid: ::std::option::Option::None,
+            mastersub_appid: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CTimedTrial_RecordPlaytime_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CTimedTrial_RecordPlaytime_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CTimedTrial_RecordPlaytime_Request.appid)
+    pub appid: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CTimedTrial_RecordPlaytime_Request.seconds_played)
+    pub seconds_played: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CTimedTrial_RecordPlaytime_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CTimedTrial_RecordPlaytime_Request {
+    fn default() -> &'a CTimedTrial_RecordPlaytime_Request {
+        <CTimedTrial_RecordPlaytime_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CTimedTrial_RecordPlaytime_Request {
+    pub fn new() -> CTimedTrial_RecordPlaytime_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 uint32 seconds_played = 2;
+
+    pub fn seconds_played(&self) -> u32 {
+        self.seconds_played.unwrap_or(0)
+    }
+
+    pub fn clear_seconds_played(&mut self) {
+        self.seconds_played = ::std::option::Option::None;
+    }
+
+    pub fn has_seconds_played(&self) -> bool {
+        self.seconds_played.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_seconds_played(&mut self, v: u32) {
+        self.seconds_played = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CTimedTrial_RecordPlaytime_Request {
+    const NAME: &'static str = "CTimedTrial_RecordPlaytime_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()?);
+                },
+                16 => {
+                    self.seconds_played = ::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.appid {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.seconds_played {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_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.appid {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.seconds_played {
+            os.write_uint32(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() -> CTimedTrial_RecordPlaytime_Request {
+        CTimedTrial_RecordPlaytime_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.appid = ::std::option::Option::None;
+        self.seconds_played = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CTimedTrial_RecordPlaytime_Request {
+        static instance: CTimedTrial_RecordPlaytime_Request = CTimedTrial_RecordPlaytime_Request {
+            appid: ::std::option::Option::None,
+            seconds_played: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CTimedTrial_RecordPlaytime_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CTimedTrial_RecordPlaytime_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CTimedTrial_RecordPlaytime_Response.seconds_played)
+    pub seconds_played: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CTimedTrial_RecordPlaytime_Response.seconds_allowed)
+    pub seconds_allowed: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CTimedTrial_RecordPlaytime_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CTimedTrial_RecordPlaytime_Response {
+    fn default() -> &'a CTimedTrial_RecordPlaytime_Response {
+        <CTimedTrial_RecordPlaytime_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CTimedTrial_RecordPlaytime_Response {
+    pub fn new() -> CTimedTrial_RecordPlaytime_Response {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 seconds_played = 1;
+
+    pub fn seconds_played(&self) -> u32 {
+        self.seconds_played.unwrap_or(0)
+    }
+
+    pub fn clear_seconds_played(&mut self) {
+        self.seconds_played = ::std::option::Option::None;
+    }
+
+    pub fn has_seconds_played(&self) -> bool {
+        self.seconds_played.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_seconds_played(&mut self, v: u32) {
+        self.seconds_played = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 seconds_allowed = 2;
+
+    pub fn seconds_allowed(&self) -> u32 {
+        self.seconds_allowed.unwrap_or(0)
+    }
+
+    pub fn clear_seconds_allowed(&mut self) {
+        self.seconds_allowed = ::std::option::Option::None;
+    }
+
+    pub fn has_seconds_allowed(&self) -> bool {
+        self.seconds_allowed.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_seconds_allowed(&mut self, v: u32) {
+        self.seconds_allowed = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CTimedTrial_RecordPlaytime_Response {
+    const NAME: &'static str = "CTimedTrial_RecordPlaytime_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.seconds_played = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                16 => {
+                    self.seconds_allowed = ::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.seconds_played {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.seconds_allowed {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_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.seconds_played {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.seconds_allowed {
+            os.write_uint32(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() -> CTimedTrial_RecordPlaytime_Response {
+        CTimedTrial_RecordPlaytime_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.seconds_played = ::std::option::Option::None;
+        self.seconds_allowed = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CTimedTrial_RecordPlaytime_Response {
+        static instance: CTimedTrial_RecordPlaytime_Response = CTimedTrial_RecordPlaytime_Response {
+            seconds_played: ::std::option::Option::None,
+            seconds_allowed: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CTimedTrial_ResetPlaytime_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CTimedTrial_ResetPlaytime_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CTimedTrial_ResetPlaytime_Request.appid)
+    pub appid: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CTimedTrial_ResetPlaytime_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CTimedTrial_ResetPlaytime_Request {
+    fn default() -> &'a CTimedTrial_ResetPlaytime_Request {
+        <CTimedTrial_ResetPlaytime_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CTimedTrial_ResetPlaytime_Request {
+    pub fn new() -> CTimedTrial_ResetPlaytime_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);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CTimedTrial_ResetPlaytime_Request {
+    const NAME: &'static str = "CTimedTrial_ResetPlaytime_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()?);
+                },
+                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);
+        }
+        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)?;
+        }
+        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() -> CTimedTrial_ResetPlaytime_Request {
+        CTimedTrial_ResetPlaytime_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.appid = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CTimedTrial_ResetPlaytime_Request {
+        static instance: CTimedTrial_ResetPlaytime_Request = CTimedTrial_ResetPlaytime_Request {
+            appid: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CTimedTrial_ResetPlaytime_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CTimedTrial_ResetPlaytime_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CTimedTrial_ResetPlaytime_Response.seconds_played)
+    pub seconds_played: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CTimedTrial_ResetPlaytime_Response.seconds_allowed)
+    pub seconds_allowed: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CTimedTrial_ResetPlaytime_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CTimedTrial_ResetPlaytime_Response {
+    fn default() -> &'a CTimedTrial_ResetPlaytime_Response {
+        <CTimedTrial_ResetPlaytime_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CTimedTrial_ResetPlaytime_Response {
+    pub fn new() -> CTimedTrial_ResetPlaytime_Response {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 seconds_played = 1;
+
+    pub fn seconds_played(&self) -> u32 {
+        self.seconds_played.unwrap_or(0)
+    }
+
+    pub fn clear_seconds_played(&mut self) {
+        self.seconds_played = ::std::option::Option::None;
+    }
+
+    pub fn has_seconds_played(&self) -> bool {
+        self.seconds_played.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_seconds_played(&mut self, v: u32) {
+        self.seconds_played = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 seconds_allowed = 2;
+
+    pub fn seconds_allowed(&self) -> u32 {
+        self.seconds_allowed.unwrap_or(0)
+    }
+
+    pub fn clear_seconds_allowed(&mut self) {
+        self.seconds_allowed = ::std::option::Option::None;
+    }
+
+    pub fn has_seconds_allowed(&self) -> bool {
+        self.seconds_allowed.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_seconds_allowed(&mut self, v: u32) {
+        self.seconds_allowed = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CTimedTrial_ResetPlaytime_Response {
+    const NAME: &'static str = "CTimedTrial_ResetPlaytime_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.seconds_played = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                16 => {
+                    self.seconds_allowed = ::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.seconds_played {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.seconds_allowed {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_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.seconds_played {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.seconds_allowed {
+            os.write_uint32(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() -> CTimedTrial_ResetPlaytime_Response {
+        CTimedTrial_ResetPlaytime_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.seconds_played = ::std::option::Option::None;
+        self.seconds_allowed = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CTimedTrial_ResetPlaytime_Response {
+        static instance: CTimedTrial_ResetPlaytime_Response = CTimedTrial_ResetPlaytime_Response {
+            seconds_played: ::std::option::Option::None,
+            seconds_allowed: ::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_base::*;
+#[allow(unused_imports)]
+use crate::steammessages_unified_base_steamclient::*;
+impl ::steam_vent_proto_common::RpcMessage for CTimedTrial_GetTimeRemaining_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 CTimedTrial_GetTimeRemaining_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
+    }
+}
+impl ::steam_vent_proto_common::RpcMessage for CTimedTrial_RecordPlaytime_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 CTimedTrial_RecordPlaytime_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
+    }
+}
+impl ::steam_vent_proto_common::RpcMessage for CTimedTrial_ResetPlaytime_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 CTimedTrial_ResetPlaytime_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
+    }
+}
+///
+struct TimedTrial {}
+impl ::steam_vent_proto_common::RpcService for TimedTrial {
+    const SERVICE_NAME: &'static str = "TimedTrial";
+}
+impl ::steam_vent_proto_common::RpcMethod for CTimedTrial_GetTimeRemaining_Request {
+    const METHOD_NAME: &'static str = "TimedTrial.GetTimeRemaining#1";
+    type Response = CTimedTrial_GetTimeRemaining_Response;
+}
+impl ::steam_vent_proto_common::RpcMethod for CTimedTrial_RecordPlaytime_Request {
+    const METHOD_NAME: &'static str = "TimedTrial.RecordPlaytime#1";
+    type Response = CTimedTrial_RecordPlaytime_Response;
+}
+impl ::steam_vent_proto_common::RpcMethod for CTimedTrial_ResetPlaytime_Request {
+    const METHOD_NAME: &'static str = "TimedTrial.ResetPlaytime#1";
+    type Response = CTimedTrial_ResetPlaytime_Response;
+}

steam/src/generated/steammessages_unified_base_steamclient.rs

@@ -0,0 +1,211 @@
+// 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.steamclient.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:NoResponse)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct NoResponse {
+    // special fields
+    // @@protoc_insertion_point(special_field:NoResponse.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a NoResponse {
+    fn default() -> &'a NoResponse {
+        <NoResponse as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl NoResponse {
+    pub fn new() -> NoResponse {
+        ::std::default::Default::default()
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for NoResponse {
+    const NAME: &'static str = "NoResponse";
+
+    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() -> NoResponse {
+        NoResponse::new()
+    }
+
+    fn clear(&mut self) {
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static NoResponse {
+        static instance: NoResponse = NoResponse {
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+#[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 = 2,
+}
+
+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),
+            2 => ::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
+    }
+}
+
+
+#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
+// @@protoc_insertion_point(enum:EProtoServiceType)
+pub enum EProtoServiceType {
+    // @@protoc_insertion_point(enum_value:EProtoServiceType.k_EProtoServiceTypeSteamMessages)
+    k_EProtoServiceTypeSteamMessages = 0,
+    // @@protoc_insertion_point(enum_value:EProtoServiceType.k_EProtoServiceTypeVRGamepadUIMessages)
+    k_EProtoServiceTypeVRGamepadUIMessages = 1,
+}
+
+impl ::steam_vent_proto_common::protobuf::Enum for EProtoServiceType {
+    const NAME: &'static str = "EProtoServiceType";
+
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<EProtoServiceType> {
+        match value {
+            0 => ::std::option::Option::Some(EProtoServiceType::k_EProtoServiceTypeSteamMessages),
+            1 => ::std::option::Option::Some(EProtoServiceType::k_EProtoServiceTypeVRGamepadUIMessages),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn from_str(str: &str) -> ::std::option::Option<EProtoServiceType> {
+        match str {
+            "k_EProtoServiceTypeSteamMessages" => ::std::option::Option::Some(EProtoServiceType::k_EProtoServiceTypeSteamMessages),
+            "k_EProtoServiceTypeVRGamepadUIMessages" => ::std::option::Option::Some(EProtoServiceType::k_EProtoServiceTypeVRGamepadUIMessages),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    const VALUES: &'static [EProtoServiceType] = &[
+        EProtoServiceType::k_EProtoServiceTypeSteamMessages,
+        EProtoServiceType::k_EProtoServiceTypeVRGamepadUIMessages,
+    ];
+}
+
+impl ::std::default::Default for EProtoServiceType {
+    fn default() -> Self {
+        EProtoServiceType::k_EProtoServiceTypeSteamMessages
+    }
+}
+
+
+// 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 NoResponse {
+    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
+    }
+}

steam/src/generated/steammessages_vac_steamclient.rs

@@ -0,0 +1,957 @@
+// 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_vac.steamclient.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:CFileVerification_SignatureCheck_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CFileVerification_SignatureCheck_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CFileVerification_SignatureCheck_Request.steamid)
+    pub steamid: ::std::option::Option<u64>,
+    // @@protoc_insertion_point(field:CFileVerification_SignatureCheck_Request.appid)
+    pub appid: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CFileVerification_SignatureCheck_Request.file_size)
+    pub file_size: ::std::option::Option<u64>,
+    // @@protoc_insertion_point(field:CFileVerification_SignatureCheck_Request.file_timestamp)
+    pub file_timestamp: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CFileVerification_SignatureCheck_Request.file_timestamp2)
+    pub file_timestamp2: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CFileVerification_SignatureCheck_Request.signature_result)
+    pub signature_result: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CFileVerification_SignatureCheck_Request.filename)
+    pub filename: ::std::option::Option<::std::string::String>,
+    // @@protoc_insertion_point(field:CFileVerification_SignatureCheck_Request.client_package_version)
+    pub client_package_version: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CFileVerification_SignatureCheck_Request.sha1hash)
+    pub sha1hash: ::std::option::Option<::std::vec::Vec<u8>>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CFileVerification_SignatureCheck_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CFileVerification_SignatureCheck_Request {
+    fn default() -> &'a CFileVerification_SignatureCheck_Request {
+        <CFileVerification_SignatureCheck_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CFileVerification_SignatureCheck_Request {
+    pub fn new() -> CFileVerification_SignatureCheck_Request {
+        ::std::default::Default::default()
+    }
+
+    // optional fixed64 steamid = 1;
+
+    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 uint32 appid = 2;
+
+    pub fn appid(&self) -> u32 {
+        self.appid.unwrap_or(0)
+    }
+
+    pub fn clear_appid(&mut self) {
+        self.appid = ::std::option::Option::None;
+    }
+
+    pub fn has_appid(&self) -> bool {
+        self.appid.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_appid(&mut self, v: u32) {
+        self.appid = ::std::option::Option::Some(v);
+    }
+
+    // optional uint64 file_size = 3;
+
+    pub fn file_size(&self) -> u64 {
+        self.file_size.unwrap_or(0)
+    }
+
+    pub fn clear_file_size(&mut self) {
+        self.file_size = ::std::option::Option::None;
+    }
+
+    pub fn has_file_size(&self) -> bool {
+        self.file_size.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_file_size(&mut self, v: u64) {
+        self.file_size = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 file_timestamp = 4;
+
+    pub fn file_timestamp(&self) -> u32 {
+        self.file_timestamp.unwrap_or(0)
+    }
+
+    pub fn clear_file_timestamp(&mut self) {
+        self.file_timestamp = ::std::option::Option::None;
+    }
+
+    pub fn has_file_timestamp(&self) -> bool {
+        self.file_timestamp.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_file_timestamp(&mut self, v: u32) {
+        self.file_timestamp = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 file_timestamp2 = 5;
+
+    pub fn file_timestamp2(&self) -> u32 {
+        self.file_timestamp2.unwrap_or(0)
+    }
+
+    pub fn clear_file_timestamp2(&mut self) {
+        self.file_timestamp2 = ::std::option::Option::None;
+    }
+
+    pub fn has_file_timestamp2(&self) -> bool {
+        self.file_timestamp2.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_file_timestamp2(&mut self, v: u32) {
+        self.file_timestamp2 = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 signature_result = 6;
+
+    pub fn signature_result(&self) -> u32 {
+        self.signature_result.unwrap_or(0)
+    }
+
+    pub fn clear_signature_result(&mut self) {
+        self.signature_result = ::std::option::Option::None;
+    }
+
+    pub fn has_signature_result(&self) -> bool {
+        self.signature_result.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_signature_result(&mut self, v: u32) {
+        self.signature_result = ::std::option::Option::Some(v);
+    }
+
+    // optional string filename = 7;
+
+    pub fn filename(&self) -> &str {
+        match self.filename.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_filename(&mut self) {
+        self.filename = ::std::option::Option::None;
+    }
+
+    pub fn has_filename(&self) -> bool {
+        self.filename.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_filename(&mut self, v: ::std::string::String) {
+        self.filename = ::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_filename(&mut self) -> &mut ::std::string::String {
+        if self.filename.is_none() {
+            self.filename = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.filename.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_filename(&mut self) -> ::std::string::String {
+        self.filename.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional uint32 client_package_version = 8;
+
+    pub fn client_package_version(&self) -> u32 {
+        self.client_package_version.unwrap_or(0)
+    }
+
+    pub fn clear_client_package_version(&mut self) {
+        self.client_package_version = ::std::option::Option::None;
+    }
+
+    pub fn has_client_package_version(&self) -> bool {
+        self.client_package_version.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_client_package_version(&mut self, v: u32) {
+        self.client_package_version = ::std::option::Option::Some(v);
+    }
+
+    // optional bytes sha1hash = 9;
+
+    pub fn sha1hash(&self) -> &[u8] {
+        match self.sha1hash.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    pub fn clear_sha1hash(&mut self) {
+        self.sha1hash = ::std::option::Option::None;
+    }
+
+    pub fn has_sha1hash(&self) -> bool {
+        self.sha1hash.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_sha1hash(&mut self, v: ::std::vec::Vec<u8>) {
+        self.sha1hash = ::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_sha1hash(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.sha1hash.is_none() {
+            self.sha1hash = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.sha1hash.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_sha1hash(&mut self) -> ::std::vec::Vec<u8> {
+        self.sha1hash.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CFileVerification_SignatureCheck_Request {
+    const NAME: &'static str = "CFileVerification_SignatureCheck_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 {
+                9 => {
+                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
+                },
+                16 => {
+                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                24 => {
+                    self.file_size = ::std::option::Option::Some(is.read_uint64()?);
+                },
+                32 => {
+                    self.file_timestamp = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                40 => {
+                    self.file_timestamp2 = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                48 => {
+                    self.signature_result = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                58 => {
+                    self.filename = ::std::option::Option::Some(is.read_string()?);
+                },
+                64 => {
+                    self.client_package_version = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                74 => {
+                    self.sha1hash = ::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.steamid {
+            my_size += 1 + 8;
+        }
+        if let Some(v) = self.appid {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
+        }
+        if let Some(v) = self.file_size {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
+        }
+        if let Some(v) = self.file_timestamp {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
+        }
+        if let Some(v) = self.file_timestamp2 {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
+        }
+        if let Some(v) = self.signature_result {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
+        }
+        if let Some(v) = self.filename.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
+        }
+        if let Some(v) = self.client_package_version {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, v);
+        }
+        if let Some(v) = self.sha1hash.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_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.steamid {
+            os.write_fixed64(1, v)?;
+        }
+        if let Some(v) = self.appid {
+            os.write_uint32(2, v)?;
+        }
+        if let Some(v) = self.file_size {
+            os.write_uint64(3, v)?;
+        }
+        if let Some(v) = self.file_timestamp {
+            os.write_uint32(4, v)?;
+        }
+        if let Some(v) = self.file_timestamp2 {
+            os.write_uint32(5, v)?;
+        }
+        if let Some(v) = self.signature_result {
+            os.write_uint32(6, v)?;
+        }
+        if let Some(v) = self.filename.as_ref() {
+            os.write_string(7, v)?;
+        }
+        if let Some(v) = self.client_package_version {
+            os.write_uint32(8, v)?;
+        }
+        if let Some(v) = self.sha1hash.as_ref() {
+            os.write_bytes(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() -> CFileVerification_SignatureCheck_Request {
+        CFileVerification_SignatureCheck_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.steamid = ::std::option::Option::None;
+        self.appid = ::std::option::Option::None;
+        self.file_size = ::std::option::Option::None;
+        self.file_timestamp = ::std::option::Option::None;
+        self.file_timestamp2 = ::std::option::Option::None;
+        self.signature_result = ::std::option::Option::None;
+        self.filename = ::std::option::Option::None;
+        self.client_package_version = ::std::option::Option::None;
+        self.sha1hash = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CFileVerification_SignatureCheck_Request {
+        static instance: CFileVerification_SignatureCheck_Request = CFileVerification_SignatureCheck_Request {
+            steamid: ::std::option::Option::None,
+            appid: ::std::option::Option::None,
+            file_size: ::std::option::Option::None,
+            file_timestamp: ::std::option::Option::None,
+            file_timestamp2: ::std::option::Option::None,
+            signature_result: ::std::option::Option::None,
+            filename: ::std::option::Option::None,
+            client_package_version: ::std::option::Option::None,
+            sha1hash: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CFileVerification_SignatureCheck_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CFileVerification_SignatureCheck_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CFileVerification_SignatureCheck_Response.deny_operation)
+    pub deny_operation: ::std::option::Option<bool>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CFileVerification_SignatureCheck_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CFileVerification_SignatureCheck_Response {
+    fn default() -> &'a CFileVerification_SignatureCheck_Response {
+        <CFileVerification_SignatureCheck_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CFileVerification_SignatureCheck_Response {
+    pub fn new() -> CFileVerification_SignatureCheck_Response {
+        ::std::default::Default::default()
+    }
+
+    // optional bool deny_operation = 1;
+
+    pub fn deny_operation(&self) -> bool {
+        self.deny_operation.unwrap_or(false)
+    }
+
+    pub fn clear_deny_operation(&mut self) {
+        self.deny_operation = ::std::option::Option::None;
+    }
+
+    pub fn has_deny_operation(&self) -> bool {
+        self.deny_operation.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_deny_operation(&mut self, v: bool) {
+        self.deny_operation = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CFileVerification_SignatureCheck_Response {
+    const NAME: &'static str = "CFileVerification_SignatureCheck_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.deny_operation = ::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.deny_operation {
+            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.deny_operation {
+            os.write_bool(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() -> CFileVerification_SignatureCheck_Response {
+        CFileVerification_SignatureCheck_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.deny_operation = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CFileVerification_SignatureCheck_Response {
+        static instance: CFileVerification_SignatureCheck_Response = CFileVerification_SignatureCheck_Response {
+            deny_operation: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CFileVerification_SteamServiceCheck_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CFileVerification_SteamServiceCheck_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CFileVerification_SteamServiceCheck_Request.service_status)
+    pub service_status: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CFileVerification_SteamServiceCheck_Request.client_package_version)
+    pub client_package_version: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CFileVerification_SteamServiceCheck_Request.launcher_type)
+    pub launcher_type: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CFileVerification_SteamServiceCheck_Request.os_type)
+    pub os_type: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CFileVerification_SteamServiceCheck_Request.service_repair)
+    pub service_repair: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CFileVerification_SteamServiceCheck_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CFileVerification_SteamServiceCheck_Request {
+    fn default() -> &'a CFileVerification_SteamServiceCheck_Request {
+        <CFileVerification_SteamServiceCheck_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CFileVerification_SteamServiceCheck_Request {
+    pub fn new() -> CFileVerification_SteamServiceCheck_Request {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 service_status = 2;
+
+    pub fn service_status(&self) -> u32 {
+        self.service_status.unwrap_or(0)
+    }
+
+    pub fn clear_service_status(&mut self) {
+        self.service_status = ::std::option::Option::None;
+    }
+
+    pub fn has_service_status(&self) -> bool {
+        self.service_status.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_service_status(&mut self, v: u32) {
+        self.service_status = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 client_package_version = 3;
+
+    pub fn client_package_version(&self) -> u32 {
+        self.client_package_version.unwrap_or(0)
+    }
+
+    pub fn clear_client_package_version(&mut self) {
+        self.client_package_version = ::std::option::Option::None;
+    }
+
+    pub fn has_client_package_version(&self) -> bool {
+        self.client_package_version.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_client_package_version(&mut self, v: u32) {
+        self.client_package_version = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 launcher_type = 4;
+
+    pub fn launcher_type(&self) -> u32 {
+        self.launcher_type.unwrap_or(0)
+    }
+
+    pub fn clear_launcher_type(&mut self) {
+        self.launcher_type = ::std::option::Option::None;
+    }
+
+    pub fn has_launcher_type(&self) -> bool {
+        self.launcher_type.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_launcher_type(&mut self, v: u32) {
+        self.launcher_type = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 os_type = 5;
+
+    pub fn os_type(&self) -> u32 {
+        self.os_type.unwrap_or(0)
+    }
+
+    pub fn clear_os_type(&mut self) {
+        self.os_type = ::std::option::Option::None;
+    }
+
+    pub fn has_os_type(&self) -> bool {
+        self.os_type.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_os_type(&mut self, v: u32) {
+        self.os_type = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 service_repair = 6;
+
+    pub fn service_repair(&self) -> u32 {
+        self.service_repair.unwrap_or(0)
+    }
+
+    pub fn clear_service_repair(&mut self) {
+        self.service_repair = ::std::option::Option::None;
+    }
+
+    pub fn has_service_repair(&self) -> bool {
+        self.service_repair.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_service_repair(&mut self, v: u32) {
+        self.service_repair = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CFileVerification_SteamServiceCheck_Request {
+    const NAME: &'static str = "CFileVerification_SteamServiceCheck_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 {
+                16 => {
+                    self.service_status = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                24 => {
+                    self.client_package_version = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                32 => {
+                    self.launcher_type = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                40 => {
+                    self.os_type = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                48 => {
+                    self.service_repair = ::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.service_status {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
+        }
+        if let Some(v) = self.client_package_version {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
+        }
+        if let Some(v) = self.launcher_type {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
+        }
+        if let Some(v) = self.os_type {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
+        }
+        if let Some(v) = self.service_repair {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, 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.service_status {
+            os.write_uint32(2, v)?;
+        }
+        if let Some(v) = self.client_package_version {
+            os.write_uint32(3, v)?;
+        }
+        if let Some(v) = self.launcher_type {
+            os.write_uint32(4, v)?;
+        }
+        if let Some(v) = self.os_type {
+            os.write_uint32(5, v)?;
+        }
+        if let Some(v) = self.service_repair {
+            os.write_uint32(6, 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() -> CFileVerification_SteamServiceCheck_Request {
+        CFileVerification_SteamServiceCheck_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.service_status = ::std::option::Option::None;
+        self.client_package_version = ::std::option::Option::None;
+        self.launcher_type = ::std::option::Option::None;
+        self.os_type = ::std::option::Option::None;
+        self.service_repair = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CFileVerification_SteamServiceCheck_Request {
+        static instance: CFileVerification_SteamServiceCheck_Request = CFileVerification_SteamServiceCheck_Request {
+            service_status: ::std::option::Option::None,
+            client_package_version: ::std::option::Option::None,
+            launcher_type: ::std::option::Option::None,
+            os_type: ::std::option::Option::None,
+            service_repair: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CFileVerification_SteamServiceCheck_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CFileVerification_SteamServiceCheck_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CFileVerification_SteamServiceCheck_Response.attempt_repair)
+    pub attempt_repair: ::std::option::Option<bool>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CFileVerification_SteamServiceCheck_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CFileVerification_SteamServiceCheck_Response {
+    fn default() -> &'a CFileVerification_SteamServiceCheck_Response {
+        <CFileVerification_SteamServiceCheck_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CFileVerification_SteamServiceCheck_Response {
+    pub fn new() -> CFileVerification_SteamServiceCheck_Response {
+        ::std::default::Default::default()
+    }
+
+    // optional bool attempt_repair = 1;
+
+    pub fn attempt_repair(&self) -> bool {
+        self.attempt_repair.unwrap_or(false)
+    }
+
+    pub fn clear_attempt_repair(&mut self) {
+        self.attempt_repair = ::std::option::Option::None;
+    }
+
+    pub fn has_attempt_repair(&self) -> bool {
+        self.attempt_repair.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_attempt_repair(&mut self, v: bool) {
+        self.attempt_repair = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CFileVerification_SteamServiceCheck_Response {
+    const NAME: &'static str = "CFileVerification_SteamServiceCheck_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.attempt_repair = ::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.attempt_repair {
+            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.attempt_repair {
+            os.write_bool(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() -> CFileVerification_SteamServiceCheck_Response {
+        CFileVerification_SteamServiceCheck_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.attempt_repair = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CFileVerification_SteamServiceCheck_Response {
+        static instance: CFileVerification_SteamServiceCheck_Response = CFileVerification_SteamServiceCheck_Response {
+            attempt_repair: ::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_base::*;
+#[allow(unused_imports)]
+use crate::steammessages_unified_base_steamclient::*;
+impl ::steam_vent_proto_common::RpcMessage for CFileVerification_SignatureCheck_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 CFileVerification_SignatureCheck_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
+    }
+}
+impl ::steam_vent_proto_common::RpcMessage
+for CFileVerification_SteamServiceCheck_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 CFileVerification_SteamServiceCheck_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
+    }
+}
+///
+struct FileVerification {}
+impl ::steam_vent_proto_common::RpcService for FileVerification {
+    const SERVICE_NAME: &'static str = "FileVerification";
+}
+impl ::steam_vent_proto_common::RpcMethod for CFileVerification_SignatureCheck_Request {
+    const METHOD_NAME: &'static str = "FileVerification.SignatureCheck#1";
+    type Response = CFileVerification_SignatureCheck_Response;
+}
+impl ::steam_vent_proto_common::RpcMethod
+for CFileVerification_SteamServiceCheck_Request {
+    const METHOD_NAME: &'static str = "FileVerification.SteamServiceCheck#1";
+    type Response = CFileVerification_SteamServiceCheck_Response;
+}

steam/src/generated/steammessages_workshop_steamclient.rs

@@ -0,0 +1,383 @@
+// 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_workshop.steamclient.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:CWorkshop_GetEULAStatus_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CWorkshop_GetEULAStatus_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CWorkshop_GetEULAStatus_Request.appid)
+    pub appid: ::std::option::Option<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CWorkshop_GetEULAStatus_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CWorkshop_GetEULAStatus_Request {
+    fn default() -> &'a CWorkshop_GetEULAStatus_Request {
+        <CWorkshop_GetEULAStatus_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CWorkshop_GetEULAStatus_Request {
+    pub fn new() -> CWorkshop_GetEULAStatus_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);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CWorkshop_GetEULAStatus_Request {
+    const NAME: &'static str = "CWorkshop_GetEULAStatus_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()?);
+                },
+                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);
+        }
+        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)?;
+        }
+        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() -> CWorkshop_GetEULAStatus_Request {
+        CWorkshop_GetEULAStatus_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.appid = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CWorkshop_GetEULAStatus_Request {
+        static instance: CWorkshop_GetEULAStatus_Request = CWorkshop_GetEULAStatus_Request {
+            appid: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CWorkshop_GetEULAStatus_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CWorkshop_GetEULAStatus_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CWorkshop_GetEULAStatus_Response.version)
+    pub version: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CWorkshop_GetEULAStatus_Response.timestamp_action)
+    pub timestamp_action: ::std::option::Option<u32>,
+    // @@protoc_insertion_point(field:CWorkshop_GetEULAStatus_Response.accepted)
+    pub accepted: ::std::option::Option<bool>,
+    // @@protoc_insertion_point(field:CWorkshop_GetEULAStatus_Response.needs_action)
+    pub needs_action: ::std::option::Option<bool>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CWorkshop_GetEULAStatus_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CWorkshop_GetEULAStatus_Response {
+    fn default() -> &'a CWorkshop_GetEULAStatus_Response {
+        <CWorkshop_GetEULAStatus_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CWorkshop_GetEULAStatus_Response {
+    pub fn new() -> CWorkshop_GetEULAStatus_Response {
+        ::std::default::Default::default()
+    }
+
+    // optional uint32 version = 1;
+
+    pub fn version(&self) -> u32 {
+        self.version.unwrap_or(0)
+    }
+
+    pub fn clear_version(&mut self) {
+        self.version = ::std::option::Option::None;
+    }
+
+    pub fn has_version(&self) -> bool {
+        self.version.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_version(&mut self, v: u32) {
+        self.version = ::std::option::Option::Some(v);
+    }
+
+    // optional uint32 timestamp_action = 2;
+
+    pub fn timestamp_action(&self) -> u32 {
+        self.timestamp_action.unwrap_or(0)
+    }
+
+    pub fn clear_timestamp_action(&mut self) {
+        self.timestamp_action = ::std::option::Option::None;
+    }
+
+    pub fn has_timestamp_action(&self) -> bool {
+        self.timestamp_action.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_timestamp_action(&mut self, v: u32) {
+        self.timestamp_action = ::std::option::Option::Some(v);
+    }
+
+    // optional bool accepted = 3;
+
+    pub fn accepted(&self) -> bool {
+        self.accepted.unwrap_or(false)
+    }
+
+    pub fn clear_accepted(&mut self) {
+        self.accepted = ::std::option::Option::None;
+    }
+
+    pub fn has_accepted(&self) -> bool {
+        self.accepted.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_accepted(&mut self, v: bool) {
+        self.accepted = ::std::option::Option::Some(v);
+    }
+
+    // optional bool needs_action = 4;
+
+    pub fn needs_action(&self) -> bool {
+        self.needs_action.unwrap_or(false)
+    }
+
+    pub fn clear_needs_action(&mut self) {
+        self.needs_action = ::std::option::Option::None;
+    }
+
+    pub fn has_needs_action(&self) -> bool {
+        self.needs_action.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_needs_action(&mut self, v: bool) {
+        self.needs_action = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CWorkshop_GetEULAStatus_Response {
+    const NAME: &'static str = "CWorkshop_GetEULAStatus_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.version = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                16 => {
+                    self.timestamp_action = ::std::option::Option::Some(is.read_uint32()?);
+                },
+                24 => {
+                    self.accepted = ::std::option::Option::Some(is.read_bool()?);
+                },
+                32 => {
+                    self.needs_action = ::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.version {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
+        }
+        if let Some(v) = self.timestamp_action {
+            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
+        }
+        if let Some(v) = self.accepted {
+            my_size += 1 + 1;
+        }
+        if let Some(v) = self.needs_action {
+            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.version {
+            os.write_uint32(1, v)?;
+        }
+        if let Some(v) = self.timestamp_action {
+            os.write_uint32(2, v)?;
+        }
+        if let Some(v) = self.accepted {
+            os.write_bool(3, v)?;
+        }
+        if let Some(v) = self.needs_action {
+            os.write_bool(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() -> CWorkshop_GetEULAStatus_Response {
+        CWorkshop_GetEULAStatus_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.version = ::std::option::Option::None;
+        self.timestamp_action = ::std::option::Option::None;
+        self.accepted = ::std::option::Option::None;
+        self.needs_action = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CWorkshop_GetEULAStatus_Response {
+        static instance: CWorkshop_GetEULAStatus_Response = CWorkshop_GetEULAStatus_Response {
+            version: ::std::option::Option::None,
+            timestamp_action: ::std::option::Option::None,
+            accepted: ::std::option::Option::None,
+            needs_action: ::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_base::*;
+#[allow(unused_imports)]
+use crate::steammessages_unified_base_steamclient::*;
+impl ::steam_vent_proto_common::RpcMessage for CWorkshop_GetEULAStatus_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 CWorkshop_GetEULAStatus_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
+    }
+}
+///
+struct Workshop {}
+impl ::steam_vent_proto_common::RpcService for Workshop {
+    const SERVICE_NAME: &'static str = "Workshop";
+}
+impl ::steam_vent_proto_common::RpcMethod for CWorkshop_GetEULAStatus_Request {
+    const METHOD_NAME: &'static str = "Workshop.GetEULAStatus#1";
+    type Response = CWorkshop_GetEULAStatus_Response;
+}

steam/src/generated/webuimessages_achievements.rs

@@ -0,0 +1,658 @@
+// 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 `webuimessages_achievements.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:CAchievements_GetInfo_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CAchievements_GetInfo_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CAchievements_GetInfo_Request.gameid)
+    pub gameid: ::std::option::Option<u64>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CAchievements_GetInfo_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CAchievements_GetInfo_Request {
+    fn default() -> &'a CAchievements_GetInfo_Request {
+        <CAchievements_GetInfo_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CAchievements_GetInfo_Request {
+    pub fn new() -> CAchievements_GetInfo_Request {
+        ::std::default::Default::default()
+    }
+
+    // optional uint64 gameid = 1;
+
+    pub fn gameid(&self) -> u64 {
+        self.gameid.unwrap_or(0)
+    }
+
+    pub fn clear_gameid(&mut self) {
+        self.gameid = ::std::option::Option::None;
+    }
+
+    pub fn has_gameid(&self) -> bool {
+        self.gameid.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_gameid(&mut self, v: u64) {
+        self.gameid = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CAchievements_GetInfo_Request {
+    const NAME: &'static str = "CAchievements_GetInfo_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.gameid = ::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.gameid {
+            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.gameid {
+            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() -> CAchievements_GetInfo_Request {
+        CAchievements_GetInfo_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.gameid = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CAchievements_GetInfo_Request {
+        static instance: CAchievements_GetInfo_Request = CAchievements_GetInfo_Request {
+            gameid: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CAchievements_GetInfo_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CAchievements_GetInfo_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CAchievements_GetInfo_Response.achievements)
+    pub achievements: ::std::vec::Vec<cachievements_get_info_response::Info>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CAchievements_GetInfo_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CAchievements_GetInfo_Response {
+    fn default() -> &'a CAchievements_GetInfo_Response {
+        <CAchievements_GetInfo_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CAchievements_GetInfo_Response {
+    pub fn new() -> CAchievements_GetInfo_Response {
+        ::std::default::Default::default()
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CAchievements_GetInfo_Response {
+    const NAME: &'static str = "CAchievements_GetInfo_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.achievements.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;
+        for value in &self.achievements {
+            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<()> {
+        for v in &self.achievements {
+            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, 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() -> CAchievements_GetInfo_Response {
+        CAchievements_GetInfo_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.achievements.clear();
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CAchievements_GetInfo_Response {
+        static instance: CAchievements_GetInfo_Response = CAchievements_GetInfo_Response {
+            achievements: ::std::vec::Vec::new(),
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+/// Nested message and enums of message `CAchievements_GetInfo_Response`
+pub mod cachievements_get_info_response {
+    // @@protoc_insertion_point(message:CAchievements_GetInfo_Response.Info)
+    #[derive(PartialEq,Clone,Default,Debug)]
+    pub struct Info {
+        // message fields
+        // @@protoc_insertion_point(field:CAchievements_GetInfo_Response.Info.id)
+        pub id: ::std::option::Option<::std::string::String>,
+        // @@protoc_insertion_point(field:CAchievements_GetInfo_Response.Info.name)
+        pub name: ::std::option::Option<::std::string::String>,
+        // @@protoc_insertion_point(field:CAchievements_GetInfo_Response.Info.desc)
+        pub desc: ::std::option::Option<::std::string::String>,
+        // @@protoc_insertion_point(field:CAchievements_GetInfo_Response.Info.image_url_achieved)
+        pub image_url_achieved: ::std::option::Option<::std::string::String>,
+        // @@protoc_insertion_point(field:CAchievements_GetInfo_Response.Info.image_url_not_achieved)
+        pub image_url_not_achieved: ::std::option::Option<::std::string::String>,
+        // @@protoc_insertion_point(field:CAchievements_GetInfo_Response.Info.achieved)
+        pub achieved: ::std::option::Option<bool>,
+        // @@protoc_insertion_point(field:CAchievements_GetInfo_Response.Info.unlock_time)
+        pub unlock_time: ::std::option::Option<u32>,
+        // special fields
+        // @@protoc_insertion_point(special_field:CAchievements_GetInfo_Response.Info.special_fields)
+        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+    }
+
+    impl<'a> ::std::default::Default for &'a Info {
+        fn default() -> &'a Info {
+            <Info as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+        }
+    }
+
+    impl Info {
+        pub fn new() -> Info {
+            ::std::default::Default::default()
+        }
+
+        // optional string id = 1;
+
+        pub fn id(&self) -> &str {
+            match self.id.as_ref() {
+                Some(v) => v,
+                None => "",
+            }
+        }
+
+        pub fn clear_id(&mut self) {
+            self.id = ::std::option::Option::None;
+        }
+
+        pub fn has_id(&self) -> bool {
+            self.id.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_id(&mut self, v: ::std::string::String) {
+            self.id = ::std::option::Option::Some(v);
+        }
+
+        // Mutable pointer to the field.
+        // If field is not initialized, it is initialized with default value first.
+        pub fn mut_id(&mut self) -> &mut ::std::string::String {
+            if self.id.is_none() {
+                self.id = ::std::option::Option::Some(::std::string::String::new());
+            }
+            self.id.as_mut().unwrap()
+        }
+
+        // Take field
+        pub fn take_id(&mut self) -> ::std::string::String {
+            self.id.take().unwrap_or_else(|| ::std::string::String::new())
+        }
+
+        // optional string name = 2;
+
+        pub fn name(&self) -> &str {
+            match self.name.as_ref() {
+                Some(v) => v,
+                None => "",
+            }
+        }
+
+        pub fn clear_name(&mut self) {
+            self.name = ::std::option::Option::None;
+        }
+
+        pub fn has_name(&self) -> bool {
+            self.name.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_name(&mut self, v: ::std::string::String) {
+            self.name = ::std::option::Option::Some(v);
+        }
+
+        // Mutable pointer to the field.
+        // If field is not initialized, it is initialized with default value first.
+        pub fn mut_name(&mut self) -> &mut ::std::string::String {
+            if self.name.is_none() {
+                self.name = ::std::option::Option::Some(::std::string::String::new());
+            }
+            self.name.as_mut().unwrap()
+        }
+
+        // Take field
+        pub fn take_name(&mut self) -> ::std::string::String {
+            self.name.take().unwrap_or_else(|| ::std::string::String::new())
+        }
+
+        // optional string desc = 3;
+
+        pub fn desc(&self) -> &str {
+            match self.desc.as_ref() {
+                Some(v) => v,
+                None => "",
+            }
+        }
+
+        pub fn clear_desc(&mut self) {
+            self.desc = ::std::option::Option::None;
+        }
+
+        pub fn has_desc(&self) -> bool {
+            self.desc.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_desc(&mut self, v: ::std::string::String) {
+            self.desc = ::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_desc(&mut self) -> &mut ::std::string::String {
+            if self.desc.is_none() {
+                self.desc = ::std::option::Option::Some(::std::string::String::new());
+            }
+            self.desc.as_mut().unwrap()
+        }
+
+        // Take field
+        pub fn take_desc(&mut self) -> ::std::string::String {
+            self.desc.take().unwrap_or_else(|| ::std::string::String::new())
+        }
+
+        // optional string image_url_achieved = 4;
+
+        pub fn image_url_achieved(&self) -> &str {
+            match self.image_url_achieved.as_ref() {
+                Some(v) => v,
+                None => "",
+            }
+        }
+
+        pub fn clear_image_url_achieved(&mut self) {
+            self.image_url_achieved = ::std::option::Option::None;
+        }
+
+        pub fn has_image_url_achieved(&self) -> bool {
+            self.image_url_achieved.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_image_url_achieved(&mut self, v: ::std::string::String) {
+            self.image_url_achieved = ::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_image_url_achieved(&mut self) -> &mut ::std::string::String {
+            if self.image_url_achieved.is_none() {
+                self.image_url_achieved = ::std::option::Option::Some(::std::string::String::new());
+            }
+            self.image_url_achieved.as_mut().unwrap()
+        }
+
+        // Take field
+        pub fn take_image_url_achieved(&mut self) -> ::std::string::String {
+            self.image_url_achieved.take().unwrap_or_else(|| ::std::string::String::new())
+        }
+
+        // optional string image_url_not_achieved = 5;
+
+        pub fn image_url_not_achieved(&self) -> &str {
+            match self.image_url_not_achieved.as_ref() {
+                Some(v) => v,
+                None => "",
+            }
+        }
+
+        pub fn clear_image_url_not_achieved(&mut self) {
+            self.image_url_not_achieved = ::std::option::Option::None;
+        }
+
+        pub fn has_image_url_not_achieved(&self) -> bool {
+            self.image_url_not_achieved.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_image_url_not_achieved(&mut self, v: ::std::string::String) {
+            self.image_url_not_achieved = ::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_image_url_not_achieved(&mut self) -> &mut ::std::string::String {
+            if self.image_url_not_achieved.is_none() {
+                self.image_url_not_achieved = ::std::option::Option::Some(::std::string::String::new());
+            }
+            self.image_url_not_achieved.as_mut().unwrap()
+        }
+
+        // Take field
+        pub fn take_image_url_not_achieved(&mut self) -> ::std::string::String {
+            self.image_url_not_achieved.take().unwrap_or_else(|| ::std::string::String::new())
+        }
+
+        // optional bool achieved = 6;
+
+        pub fn achieved(&self) -> bool {
+            self.achieved.unwrap_or(false)
+        }
+
+        pub fn clear_achieved(&mut self) {
+            self.achieved = ::std::option::Option::None;
+        }
+
+        pub fn has_achieved(&self) -> bool {
+            self.achieved.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_achieved(&mut self, v: bool) {
+            self.achieved = ::std::option::Option::Some(v);
+        }
+
+        // optional uint32 unlock_time = 7;
+
+        pub fn unlock_time(&self) -> u32 {
+            self.unlock_time.unwrap_or(0)
+        }
+
+        pub fn clear_unlock_time(&mut self) {
+            self.unlock_time = ::std::option::Option::None;
+        }
+
+        pub fn has_unlock_time(&self) -> bool {
+            self.unlock_time.is_some()
+        }
+
+        // Param is passed by value, moved
+        pub fn set_unlock_time(&mut self, v: u32) {
+            self.unlock_time = ::std::option::Option::Some(v);
+        }
+    }
+
+    impl ::steam_vent_proto_common::protobuf::Message for Info {
+        const NAME: &'static str = "Info";
+
+        fn is_initialized(&self) -> bool {
+            true
+        }
+
+        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+            while let Some(tag) = is.read_raw_tag_or_eof()? {
+                match tag {
+                    10 => {
+                        self.id = ::std::option::Option::Some(is.read_string()?);
+                    },
+                    18 => {
+                        self.name = ::std::option::Option::Some(is.read_string()?);
+                    },
+                    26 => {
+                        self.desc = ::std::option::Option::Some(is.read_string()?);
+                    },
+                    34 => {
+                        self.image_url_achieved = ::std::option::Option::Some(is.read_string()?);
+                    },
+                    42 => {
+                        self.image_url_not_achieved = ::std::option::Option::Some(is.read_string()?);
+                    },
+                    48 => {
+                        self.achieved = ::std::option::Option::Some(is.read_bool()?);
+                    },
+                    56 => {
+                        self.unlock_time = ::std::option::Option::Some(is.read_uint32()?);
+                    },
+                    tag => {
+                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
+                    },
+                };
+            }
+            ::std::result::Result::Ok(())
+        }
+
+        // Compute sizes of nested messages
+        #[allow(unused_variables)]
+        fn compute_size(&self) -> u64 {
+            let mut my_size = 0;
+            if let Some(v) = self.id.as_ref() {
+                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
+            }
+            if let Some(v) = self.name.as_ref() {
+                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
+            }
+            if let Some(v) = self.desc.as_ref() {
+                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
+            }
+            if let Some(v) = self.image_url_achieved.as_ref() {
+                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
+            }
+            if let Some(v) = self.image_url_not_achieved.as_ref() {
+                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &v);
+            }
+            if let Some(v) = self.achieved {
+                my_size += 1 + 1;
+            }
+            if let Some(v) = self.unlock_time {
+                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
+            }
+            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+            self.special_fields.cached_size().set(my_size as u32);
+            my_size
+        }
+
+        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+            if let Some(v) = self.id.as_ref() {
+                os.write_string(1, v)?;
+            }
+            if let Some(v) = self.name.as_ref() {
+                os.write_string(2, v)?;
+            }
+            if let Some(v) = self.desc.as_ref() {
+                os.write_string(3, v)?;
+            }
+            if let Some(v) = self.image_url_achieved.as_ref() {
+                os.write_string(4, v)?;
+            }
+            if let Some(v) = self.image_url_not_achieved.as_ref() {
+                os.write_string(5, v)?;
+            }
+            if let Some(v) = self.achieved {
+                os.write_bool(6, v)?;
+            }
+            if let Some(v) = self.unlock_time {
+                os.write_uint32(7, 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() -> Info {
+            Info::new()
+        }
+
+        fn clear(&mut self) {
+            self.id = ::std::option::Option::None;
+            self.name = ::std::option::Option::None;
+            self.desc = ::std::option::Option::None;
+            self.image_url_achieved = ::std::option::Option::None;
+            self.image_url_not_achieved = ::std::option::Option::None;
+            self.achieved = ::std::option::Option::None;
+            self.unlock_time = ::std::option::Option::None;
+            self.special_fields.clear();
+        }
+
+        fn default_instance() -> &'static Info {
+            static instance: Info = Info {
+                id: ::std::option::Option::None,
+                name: ::std::option::Option::None,
+                desc: ::std::option::Option::None,
+                image_url_achieved: ::std::option::Option::None,
+                image_url_not_achieved: ::std::option::Option::None,
+                achieved: ::std::option::Option::None,
+                unlock_time: ::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_base::*;
+#[allow(unused_imports)]
+use crate::webuimessages_base::*;
+impl ::steam_vent_proto_common::RpcMessage for CAchievements_GetInfo_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 CAchievements_GetInfo_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
+    }
+}
+///
+struct Achievements {}
+impl ::steam_vent_proto_common::RpcService for Achievements {
+    const SERVICE_NAME: &'static str = "Achievements";
+}
+impl ::steam_vent_proto_common::RpcMethod for CAchievements_GetInfo_Request {
+    const METHOD_NAME: &'static str = "Achievements.GetInfo#1";
+    type Response = CAchievements_GetInfo_Response;
+}

steam/src/generated/webuimessages_base.rs

@@ -0,0 +1,180 @@
+// 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 `webuimessages_base.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:WebUINoResponse)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct WebUINoResponse {
+    // special fields
+    // @@protoc_insertion_point(special_field:WebUINoResponse.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a WebUINoResponse {
+    fn default() -> &'a WebUINoResponse {
+        <WebUINoResponse as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl WebUINoResponse {
+    pub fn new() -> WebUINoResponse {
+        ::std::default::Default::default()
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for WebUINoResponse {
+    const NAME: &'static str = "WebUINoResponse";
+
+    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() -> WebUINoResponse {
+        WebUINoResponse::new()
+    }
+
+    fn clear(&mut self) {
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static WebUINoResponse {
+        static instance: WebUINoResponse = WebUINoResponse {
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
+// @@protoc_insertion_point(enum:EClientExecutionSite)
+pub enum EClientExecutionSite {
+    // @@protoc_insertion_point(enum_value:EClientExecutionSite.k_EClientExecutionSiteInvalid)
+    k_EClientExecutionSiteInvalid = 0,
+    // @@protoc_insertion_point(enum_value:EClientExecutionSite.k_EClientExecutionSiteSteamUI)
+    k_EClientExecutionSiteSteamUI = 1,
+    // @@protoc_insertion_point(enum_value:EClientExecutionSite.k_EClientExecutionSiteClientdll)
+    k_EClientExecutionSiteClientdll = 2,
+    // @@protoc_insertion_point(enum_value:EClientExecutionSite.k_EClientExecutionSiteAny)
+    k_EClientExecutionSiteAny = 3,
+}
+
+impl ::steam_vent_proto_common::protobuf::Enum for EClientExecutionSite {
+    const NAME: &'static str = "EClientExecutionSite";
+
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<EClientExecutionSite> {
+        match value {
+            0 => ::std::option::Option::Some(EClientExecutionSite::k_EClientExecutionSiteInvalid),
+            1 => ::std::option::Option::Some(EClientExecutionSite::k_EClientExecutionSiteSteamUI),
+            2 => ::std::option::Option::Some(EClientExecutionSite::k_EClientExecutionSiteClientdll),
+            3 => ::std::option::Option::Some(EClientExecutionSite::k_EClientExecutionSiteAny),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn from_str(str: &str) -> ::std::option::Option<EClientExecutionSite> {
+        match str {
+            "k_EClientExecutionSiteInvalid" => ::std::option::Option::Some(EClientExecutionSite::k_EClientExecutionSiteInvalid),
+            "k_EClientExecutionSiteSteamUI" => ::std::option::Option::Some(EClientExecutionSite::k_EClientExecutionSiteSteamUI),
+            "k_EClientExecutionSiteClientdll" => ::std::option::Option::Some(EClientExecutionSite::k_EClientExecutionSiteClientdll),
+            "k_EClientExecutionSiteAny" => ::std::option::Option::Some(EClientExecutionSite::k_EClientExecutionSiteAny),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    const VALUES: &'static [EClientExecutionSite] = &[
+        EClientExecutionSite::k_EClientExecutionSiteInvalid,
+        EClientExecutionSite::k_EClientExecutionSiteSteamUI,
+        EClientExecutionSite::k_EClientExecutionSiteClientdll,
+        EClientExecutionSite::k_EClientExecutionSiteAny,
+    ];
+}
+
+impl ::std::default::Default for EClientExecutionSite {
+    fn default() -> Self {
+        EClientExecutionSite::k_EClientExecutionSiteInvalid
+    }
+}
+
+
+// Extension generation with lite runtime is not supported
+
+
+const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;
+
+#[allow(unused_imports)]
+use crate::enums::*;
+#[allow(unused_imports)]
+use crate::steammessages_base::*;
+impl ::steam_vent_proto_common::RpcMessage for WebUINoResponse {
+    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
+    }
+}

steam/src/generated/webuimessages_gamenotes.rs

@@ -0,0 +1,419 @@
+// 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 `webuimessages_gamenotes.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:CGameNotes_UploadImage_Request)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CGameNotes_UploadImage_Request {
+    // message fields
+    // @@protoc_insertion_point(field:CGameNotes_UploadImage_Request.file_prefix)
+    pub file_prefix: ::std::option::Option<::std::string::String>,
+    // @@protoc_insertion_point(field:CGameNotes_UploadImage_Request.mime_type)
+    pub mime_type: ::std::option::Option<::std::string::String>,
+    // @@protoc_insertion_point(field:CGameNotes_UploadImage_Request.data)
+    pub data: ::std::option::Option<::std::vec::Vec<u8>>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CGameNotes_UploadImage_Request.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CGameNotes_UploadImage_Request {
+    fn default() -> &'a CGameNotes_UploadImage_Request {
+        <CGameNotes_UploadImage_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CGameNotes_UploadImage_Request {
+    pub fn new() -> CGameNotes_UploadImage_Request {
+        ::std::default::Default::default()
+    }
+
+    // optional string file_prefix = 1;
+
+    pub fn file_prefix(&self) -> &str {
+        match self.file_prefix.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_file_prefix(&mut self) {
+        self.file_prefix = ::std::option::Option::None;
+    }
+
+    pub fn has_file_prefix(&self) -> bool {
+        self.file_prefix.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_file_prefix(&mut self, v: ::std::string::String) {
+        self.file_prefix = ::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_file_prefix(&mut self) -> &mut ::std::string::String {
+        if self.file_prefix.is_none() {
+            self.file_prefix = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.file_prefix.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_file_prefix(&mut self) -> ::std::string::String {
+        self.file_prefix.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional string mime_type = 2;
+
+    pub fn mime_type(&self) -> &str {
+        match self.mime_type.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_mime_type(&mut self) {
+        self.mime_type = ::std::option::Option::None;
+    }
+
+    pub fn has_mime_type(&self) -> bool {
+        self.mime_type.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_mime_type(&mut self, v: ::std::string::String) {
+        self.mime_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_mime_type(&mut self) -> &mut ::std::string::String {
+        if self.mime_type.is_none() {
+            self.mime_type = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.mime_type.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_mime_type(&mut self) -> ::std::string::String {
+        self.mime_type.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional bytes data = 3;
+
+    pub fn data(&self) -> &[u8] {
+        match self.data.as_ref() {
+            Some(v) => v,
+            None => &[],
+        }
+    }
+
+    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: ::std::vec::Vec<u8>) {
+        self.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_data(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.data.is_none() {
+            self.data = ::std::option::Option::Some(::std::vec::Vec::new());
+        }
+        self.data.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_data(&mut self) -> ::std::vec::Vec<u8> {
+        self.data.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CGameNotes_UploadImage_Request {
+    const NAME: &'static str = "CGameNotes_UploadImage_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.file_prefix = ::std::option::Option::Some(is.read_string()?);
+                },
+                18 => {
+                    self.mime_type = ::std::option::Option::Some(is.read_string()?);
+                },
+                26 => {
+                    self.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.file_prefix.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
+        }
+        if let Some(v) = self.mime_type.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
+        }
+        if let Some(v) = self.data.as_ref() {
+            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(3, &v);
+        }
+        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
+        if let Some(v) = self.file_prefix.as_ref() {
+            os.write_string(1, v)?;
+        }
+        if let Some(v) = self.mime_type.as_ref() {
+            os.write_string(2, v)?;
+        }
+        if let Some(v) = self.data.as_ref() {
+            os.write_bytes(3, v)?;
+        }
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> CGameNotes_UploadImage_Request {
+        CGameNotes_UploadImage_Request::new()
+    }
+
+    fn clear(&mut self) {
+        self.file_prefix = ::std::option::Option::None;
+        self.mime_type = ::std::option::Option::None;
+        self.data = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CGameNotes_UploadImage_Request {
+        static instance: CGameNotes_UploadImage_Request = CGameNotes_UploadImage_Request {
+            file_prefix: ::std::option::Option::None,
+            mime_type: ::std::option::Option::None,
+            data: ::std::option::Option::None,
+            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+// @@protoc_insertion_point(message:CGameNotes_UploadImage_Response)
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct CGameNotes_UploadImage_Response {
+    // message fields
+    // @@protoc_insertion_point(field:CGameNotes_UploadImage_Response.filename)
+    pub filename: ::std::option::Option<::std::string::String>,
+    // special fields
+    // @@protoc_insertion_point(special_field:CGameNotes_UploadImage_Response.special_fields)
+    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a CGameNotes_UploadImage_Response {
+    fn default() -> &'a CGameNotes_UploadImage_Response {
+        <CGameNotes_UploadImage_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
+    }
+}
+
+impl CGameNotes_UploadImage_Response {
+    pub fn new() -> CGameNotes_UploadImage_Response {
+        ::std::default::Default::default()
+    }
+
+    // optional string filename = 1;
+
+    pub fn filename(&self) -> &str {
+        match self.filename.as_ref() {
+            Some(v) => v,
+            None => "",
+        }
+    }
+
+    pub fn clear_filename(&mut self) {
+        self.filename = ::std::option::Option::None;
+    }
+
+    pub fn has_filename(&self) -> bool {
+        self.filename.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_filename(&mut self, v: ::std::string::String) {
+        self.filename = ::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_filename(&mut self) -> &mut ::std::string::String {
+        if self.filename.is_none() {
+            self.filename = ::std::option::Option::Some(::std::string::String::new());
+        }
+        self.filename.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_filename(&mut self) -> ::std::string::String {
+        self.filename.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+}
+
+impl ::steam_vent_proto_common::protobuf::Message for CGameNotes_UploadImage_Response {
+    const NAME: &'static str = "CGameNotes_UploadImage_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.filename = ::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.filename.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.filename.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() -> CGameNotes_UploadImage_Response {
+        CGameNotes_UploadImage_Response::new()
+    }
+
+    fn clear(&mut self) {
+        self.filename = ::std::option::Option::None;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static CGameNotes_UploadImage_Response {
+        static instance: CGameNotes_UploadImage_Response = CGameNotes_UploadImage_Response {
+            filename: ::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_base::*;
+#[allow(unused_imports)]
+use crate::webuimessages_base::*;
+impl ::steam_vent_proto_common::RpcMessage for CGameNotes_UploadImage_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 CGameNotes_UploadImage_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
+    }
+}
+///
+struct GameNotes {}
+impl ::steam_vent_proto_common::RpcService for GameNotes {
+    const SERVICE_NAME: &'static str = "GameNotes";
+}
+impl ::steam_vent_proto_common::RpcMethod for CGameNotes_UploadImage_Request {
+    const METHOD_NAME: &'static str = "GameNotes.UploadImage#1";
+    type Response = CGameNotes_UploadImage_Response;
+}