// 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_friendmessages.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:CFriendMessages_GetRecentMessages_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CFriendMessages_GetRecentMessages_Request {
    // message fields
    // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Request.steamid1)
    pub steamid1: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Request.steamid2)
    pub steamid2: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Request.count)
    pub count: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Request.most_recent_conversation)
    pub most_recent_conversation: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Request.rtime32_start_time)
    pub rtime32_start_time: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Request.bbcode_format)
    pub bbcode_format: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Request.start_ordinal)
    pub start_ordinal: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Request.time_last)
    pub time_last: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Request.ordinal_last)
    pub ordinal_last: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CFriendMessages_GetRecentMessages_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed64 steamid1 = 1;

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

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

    pub fn has_steamid1(&self) -> bool {
        self.steamid1.is_some()
    }

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

    // optional fixed64 steamid2 = 2;

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

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

    pub fn has_steamid2(&self) -> bool {
        self.steamid2.is_some()
    }

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

    // optional uint32 count = 3;

    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 bool most_recent_conversation = 4;

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

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

    pub fn has_most_recent_conversation(&self) -> bool {
        self.most_recent_conversation.is_some()
    }

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

    // optional fixed32 rtime32_start_time = 5;

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

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

    pub fn has_rtime32_start_time(&self) -> bool {
        self.rtime32_start_time.is_some()
    }

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

    // optional bool bbcode_format = 6;

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

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

    pub fn has_bbcode_format(&self) -> bool {
        self.bbcode_format.is_some()
    }

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

    // optional uint32 start_ordinal = 7;

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

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

    pub fn has_start_ordinal(&self) -> bool {
        self.start_ordinal.is_some()
    }

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

    // optional uint32 time_last = 8;

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

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

    pub fn has_time_last(&self) -> bool {
        self.time_last.is_some()
    }

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

    // optional uint32 ordinal_last = 9;

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

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

    pub fn has_ordinal_last(&self) -> bool {
        self.ordinal_last.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CFriendMessages_GetRecentMessages_Request {
    const NAME: &'static str = "CFriendMessages_GetRecentMessages_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.steamid1 = ::std::option::Option::Some(is.read_fixed64()?);
                },
                17 => {
                    self.steamid2 = ::std::option::Option::Some(is.read_fixed64()?);
                },
                24 => {
                    self.count = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.most_recent_conversation = ::std::option::Option::Some(is.read_bool()?);
                },
                45 => {
                    self.rtime32_start_time = ::std::option::Option::Some(is.read_fixed32()?);
                },
                48 => {
                    self.bbcode_format = ::std::option::Option::Some(is.read_bool()?);
                },
                56 => {
                    self.start_ordinal = ::std::option::Option::Some(is.read_uint32()?);
                },
                64 => {
                    self.time_last = ::std::option::Option::Some(is.read_uint32()?);
                },
                72 => {
                    self.ordinal_last = ::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.steamid1 {
            my_size += 1 + 8;
        }
        if let Some(v) = self.steamid2 {
            my_size += 1 + 8;
        }
        if let Some(v) = self.count {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.most_recent_conversation {
            my_size += 1 + 1;
        }
        if let Some(v) = self.rtime32_start_time {
            my_size += 1 + 4;
        }
        if let Some(v) = self.bbcode_format {
            my_size += 1 + 1;
        }
        if let Some(v) = self.start_ordinal {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.time_last {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, v);
        }
        if let Some(v) = self.ordinal_last {
            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.steamid1 {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.steamid2 {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.count {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.most_recent_conversation {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.rtime32_start_time {
            os.write_fixed32(5, v)?;
        }
        if let Some(v) = self.bbcode_format {
            os.write_bool(6, v)?;
        }
        if let Some(v) = self.start_ordinal {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.time_last {
            os.write_uint32(8, v)?;
        }
        if let Some(v) = self.ordinal_last {
            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() -> CFriendMessages_GetRecentMessages_Request {
        CFriendMessages_GetRecentMessages_Request::new()
    }

    fn clear(&mut self) {
        self.steamid1 = ::std::option::Option::None;
        self.steamid2 = ::std::option::Option::None;
        self.count = ::std::option::Option::None;
        self.most_recent_conversation = ::std::option::Option::None;
        self.rtime32_start_time = ::std::option::Option::None;
        self.bbcode_format = ::std::option::Option::None;
        self.start_ordinal = ::std::option::Option::None;
        self.time_last = ::std::option::Option::None;
        self.ordinal_last = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CFriendMessages_GetRecentMessages_Request {
        static instance: CFriendMessages_GetRecentMessages_Request = CFriendMessages_GetRecentMessages_Request {
            steamid1: ::std::option::Option::None,
            steamid2: ::std::option::Option::None,
            count: ::std::option::Option::None,
            most_recent_conversation: ::std::option::Option::None,
            rtime32_start_time: ::std::option::Option::None,
            bbcode_format: ::std::option::Option::None,
            start_ordinal: ::std::option::Option::None,
            time_last: ::std::option::Option::None,
            ordinal_last: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CFriendMessages_GetRecentMessages_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CFriendMessages_GetRecentMessages_Response {
    // message fields
    // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Response.messages)
    pub messages: ::std::vec::Vec<cfriend_messages_get_recent_messages_response::FriendMessage>,
    // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Response.more_available)
    pub more_available: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CFriendMessages_GetRecentMessages_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional bool more_available = 4;

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

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

    pub fn has_more_available(&self) -> bool {
        self.more_available.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CFriendMessages_GetRecentMessages_Response {
    const NAME: &'static str = "CFriendMessages_GetRecentMessages_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.messages.push(is.read_message()?);
                },
                32 => {
                    self.more_available = ::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;
        for value in &self.messages {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.more_available {
            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<()> {
        for v in &self.messages {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        if let Some(v) = self.more_available {
            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() -> CFriendMessages_GetRecentMessages_Response {
        CFriendMessages_GetRecentMessages_Response::new()
    }

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

    fn default_instance() -> &'static CFriendMessages_GetRecentMessages_Response {
        static instance: CFriendMessages_GetRecentMessages_Response = CFriendMessages_GetRecentMessages_Response {
            messages: ::std::vec::Vec::new(),
            more_available: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CFriendMessages_GetRecentMessages_Response`
pub mod cfriend_messages_get_recent_messages_response {
    // @@protoc_insertion_point(message:CFriendMessages_GetRecentMessages_Response.FriendMessage)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct FriendMessage {
        // message fields
        // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Response.FriendMessage.accountid)
        pub accountid: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Response.FriendMessage.timestamp)
        pub timestamp: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Response.FriendMessage.message)
        pub message: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Response.FriendMessage.ordinal)
        pub ordinal: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Response.FriendMessage.reactions)
        pub reactions: ::std::vec::Vec<friend_message::MessageReaction>,
        // special fields
        // @@protoc_insertion_point(special_field:CFriendMessages_GetRecentMessages_Response.FriendMessage.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

    impl FriendMessage {
        pub fn new() -> FriendMessage {
            ::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 uint32 timestamp = 2;

        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 string message = 3;

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

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

        pub fn has_message(&self) -> bool {
            self.message.is_some()
        }

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

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

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

        // optional uint32 ordinal = 4;

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

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

        pub fn has_ordinal(&self) -> bool {
            self.ordinal.is_some()
        }

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

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

        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()?);
                    },
                    16 => {
                        self.timestamp = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    26 => {
                        self.message = ::std::option::Option::Some(is.read_string()?);
                    },
                    32 => {
                        self.ordinal = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    42 => {
                        self.reactions.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.accountid {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
            }
            if let Some(v) = self.timestamp {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
            }
            if let Some(v) = self.message.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
            }
            if let Some(v) = self.ordinal {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
            }
            for value in &self.reactions {
                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.accountid {
                os.write_uint32(1, v)?;
            }
            if let Some(v) = self.timestamp {
                os.write_uint32(2, v)?;
            }
            if let Some(v) = self.message.as_ref() {
                os.write_string(3, v)?;
            }
            if let Some(v) = self.ordinal {
                os.write_uint32(4, v)?;
            }
            for v in &self.reactions {
                ::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() -> FriendMessage {
            FriendMessage::new()
        }

        fn clear(&mut self) {
            self.accountid = ::std::option::Option::None;
            self.timestamp = ::std::option::Option::None;
            self.message = ::std::option::Option::None;
            self.ordinal = ::std::option::Option::None;
            self.reactions.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static FriendMessage {
            static instance: FriendMessage = FriendMessage {
                accountid: ::std::option::Option::None,
                timestamp: ::std::option::Option::None,
                message: ::std::option::Option::None,
                ordinal: ::std::option::Option::None,
                reactions: ::std::vec::Vec::new(),
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `FriendMessage`
    pub mod friend_message {
        // @@protoc_insertion_point(message:CFriendMessages_GetRecentMessages_Response.FriendMessage.MessageReaction)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct MessageReaction {
            // message fields
            // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Response.FriendMessage.MessageReaction.reaction_type)
            pub reaction_type: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::super::EMessageReactionType>>,
            // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Response.FriendMessage.MessageReaction.reaction)
            pub reaction: ::std::option::Option<::std::string::String>,
            // @@protoc_insertion_point(field:CFriendMessages_GetRecentMessages_Response.FriendMessage.MessageReaction.reactors)
            pub reactors: ::std::vec::Vec<u32>,
            // special fields
            // @@protoc_insertion_point(special_field:CFriendMessages_GetRecentMessages_Response.FriendMessage.MessageReaction.special_fields)
            pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
        }

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

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

            // optional .EMessageReactionType reaction_type = 1;

            pub fn reaction_type(&self) -> super::super::EMessageReactionType {
                match self.reaction_type {
                    Some(e) => e.enum_value_or(super::super::EMessageReactionType::k_EMessageReactionType_Invalid),
                    None => super::super::EMessageReactionType::k_EMessageReactionType_Invalid,
                }
            }

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

            pub fn has_reaction_type(&self) -> bool {
                self.reaction_type.is_some()
            }

            // Param is passed by value, moved
            pub fn set_reaction_type(&mut self, v: super::super::EMessageReactionType) {
                self.reaction_type = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
            }

            // optional string reaction = 2;

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

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

            pub fn has_reaction(&self) -> bool {
                self.reaction.is_some()
            }

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

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

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

            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.reaction_type = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                        },
                        18 => {
                            self.reaction = ::std::option::Option::Some(is.read_string()?);
                        },
                        26 => {
                            is.read_repeated_packed_uint32_into(&mut self.reactors)?;
                        },
                        24 => {
                            self.reactors.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.reaction_type {
                    my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v.value());
                }
                if let Some(v) = self.reaction.as_ref() {
                    my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
                }
                for value in &self.reactors {
                    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.reaction_type {
                    os.write_enum(1, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
                }
                if let Some(v) = self.reaction.as_ref() {
                    os.write_string(2, v)?;
                }
                for v in &self.reactors {
                    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() -> MessageReaction {
                MessageReaction::new()
            }

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

            fn default_instance() -> &'static MessageReaction {
                static instance: MessageReaction = MessageReaction {
                    reaction_type: ::std::option::Option::None,
                    reaction: ::std::option::Option::None,
                    reactors: ::std::vec::Vec::new(),
                    special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }
    }
}

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

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

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

    // optional uint32 lastmessage_since = 1;

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

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

    pub fn has_lastmessage_since(&self) -> bool {
        self.lastmessage_since.is_some()
    }

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

    // optional bool only_sessions_with_messages = 2;

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

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

    pub fn has_only_sessions_with_messages(&self) -> bool {
        self.only_sessions_with_messages.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CFriendsMessages_GetActiveMessageSessions_Request {
    const NAME: &'static str = "CFriendsMessages_GetActiveMessageSessions_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.lastmessage_since = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.only_sessions_with_messages = ::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.lastmessage_since {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.only_sessions_with_messages {
            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.lastmessage_since {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.only_sessions_with_messages {
            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() -> CFriendsMessages_GetActiveMessageSessions_Request {
        CFriendsMessages_GetActiveMessageSessions_Request::new()
    }

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

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

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

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

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

    // optional uint32 timestamp = 2;

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

impl ::steam_vent_proto_common::protobuf::Message for CFriendsMessages_GetActiveMessageSessions_Response {
    const NAME: &'static str = "CFriendsMessages_GetActiveMessageSessions_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.message_sessions.push(is.read_message()?);
                },
                16 => {
                    self.timestamp = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.message_sessions {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.timestamp {
            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<()> {
        for v in &self.message_sessions {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        if let Some(v) = self.timestamp {
            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() -> CFriendsMessages_GetActiveMessageSessions_Response {
        CFriendsMessages_GetActiveMessageSessions_Response::new()
    }

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

    fn default_instance() -> &'static CFriendsMessages_GetActiveMessageSessions_Response {
        static instance: CFriendsMessages_GetActiveMessageSessions_Response = CFriendsMessages_GetActiveMessageSessions_Response {
            message_sessions: ::std::vec::Vec::new(),
            timestamp: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CFriendsMessages_GetActiveMessageSessions_Response`
pub mod cfriends_messages_get_active_message_sessions_response {
    // @@protoc_insertion_point(message:CFriendsMessages_GetActiveMessageSessions_Response.FriendMessageSession)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct FriendMessageSession {
        // message fields
        // @@protoc_insertion_point(field:CFriendsMessages_GetActiveMessageSessions_Response.FriendMessageSession.accountid_friend)
        pub accountid_friend: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CFriendsMessages_GetActiveMessageSessions_Response.FriendMessageSession.last_message)
        pub last_message: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CFriendsMessages_GetActiveMessageSessions_Response.FriendMessageSession.last_view)
        pub last_view: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CFriendsMessages_GetActiveMessageSessions_Response.FriendMessageSession.unread_message_count)
        pub unread_message_count: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CFriendsMessages_GetActiveMessageSessions_Response.FriendMessageSession.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional uint32 accountid_friend = 1;

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

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

        pub fn has_accountid_friend(&self) -> bool {
            self.accountid_friend.is_some()
        }

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

        // optional uint32 last_message = 2;

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

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

        pub fn has_last_message(&self) -> bool {
            self.last_message.is_some()
        }

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

        // optional uint32 last_view = 3;

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

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

        pub fn has_last_view(&self) -> bool {
            self.last_view.is_some()
        }

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

        // optional uint32 unread_message_count = 4;

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

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

        pub fn has_unread_message_count(&self) -> bool {
            self.unread_message_count.is_some()
        }

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

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

        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_friend = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    16 => {
                        self.last_message = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    24 => {
                        self.last_view = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    32 => {
                        self.unread_message_count = ::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.accountid_friend {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
            }
            if let Some(v) = self.last_message {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
            }
            if let Some(v) = self.last_view {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
            }
            if let Some(v) = self.unread_message_count {
                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.accountid_friend {
                os.write_uint32(1, v)?;
            }
            if let Some(v) = self.last_message {
                os.write_uint32(2, v)?;
            }
            if let Some(v) = self.last_view {
                os.write_uint32(3, v)?;
            }
            if let Some(v) = self.unread_message_count {
                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() -> FriendMessageSession {
            FriendMessageSession::new()
        }

        fn clear(&mut self) {
            self.accountid_friend = ::std::option::Option::None;
            self.last_message = ::std::option::Option::None;
            self.last_view = ::std::option::Option::None;
            self.unread_message_count = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static FriendMessageSession {
            static instance: FriendMessageSession = FriendMessageSession {
                accountid_friend: ::std::option::Option::None,
                last_message: ::std::option::Option::None,
                last_view: ::std::option::Option::None,
                unread_message_count: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CFriendMessages_SendMessage_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CFriendMessages_SendMessage_Request {
    // message fields
    // @@protoc_insertion_point(field:CFriendMessages_SendMessage_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CFriendMessages_SendMessage_Request.chat_entry_type)
    pub chat_entry_type: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CFriendMessages_SendMessage_Request.message)
    pub message: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CFriendMessages_SendMessage_Request.contains_bbcode)
    pub contains_bbcode: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CFriendMessages_SendMessage_Request.echo_to_sender)
    pub echo_to_sender: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CFriendMessages_SendMessage_Request.low_priority)
    pub low_priority: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CFriendMessages_SendMessage_Request.client_message_id)
    pub client_message_id: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CFriendMessages_SendMessage_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl CFriendMessages_SendMessage_Request {
    pub fn new() -> CFriendMessages_SendMessage_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 int32 chat_entry_type = 2;

    pub fn chat_entry_type(&self) -> i32 {
        self.chat_entry_type.unwrap_or(0)
    }

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

    pub fn has_chat_entry_type(&self) -> bool {
        self.chat_entry_type.is_some()
    }

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

    // optional string message = 3;

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

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

    pub fn has_message(&self) -> bool {
        self.message.is_some()
    }

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

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

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

    // optional bool contains_bbcode = 4;

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

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

    pub fn has_contains_bbcode(&self) -> bool {
        self.contains_bbcode.is_some()
    }

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

    // optional bool echo_to_sender = 5;

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

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

    pub fn has_echo_to_sender(&self) -> bool {
        self.echo_to_sender.is_some()
    }

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

    // optional bool low_priority = 6;

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

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

    pub fn has_low_priority(&self) -> bool {
        self.low_priority.is_some()
    }

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

    // optional string client_message_id = 8;

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

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

    pub fn has_client_message_id(&self) -> bool {
        self.client_message_id.is_some()
    }

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

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

impl ::steam_vent_proto_common::protobuf::Message for CFriendMessages_SendMessage_Request {
    const NAME: &'static str = "CFriendMessages_SendMessage_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.chat_entry_type = ::std::option::Option::Some(is.read_int32()?);
                },
                26 => {
                    self.message = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.contains_bbcode = ::std::option::Option::Some(is.read_bool()?);
                },
                40 => {
                    self.echo_to_sender = ::std::option::Option::Some(is.read_bool()?);
                },
                48 => {
                    self.low_priority = ::std::option::Option::Some(is.read_bool()?);
                },
                66 => {
                    self.client_message_id = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.chat_entry_type {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.message.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.contains_bbcode {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.echo_to_sender {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.low_priority {
            os.write_bool(6, v)?;
        }
        if let Some(v) = self.client_message_id.as_ref() {
            os.write_string(8, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.chat_entry_type = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.contains_bbcode = ::std::option::Option::None;
        self.echo_to_sender = ::std::option::Option::None;
        self.low_priority = ::std::option::Option::None;
        self.client_message_id = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CFriendMessages_SendMessage_Request {
        static instance: CFriendMessages_SendMessage_Request = CFriendMessages_SendMessage_Request {
            steamid: ::std::option::Option::None,
            chat_entry_type: ::std::option::Option::None,
            message: ::std::option::Option::None,
            contains_bbcode: ::std::option::Option::None,
            echo_to_sender: ::std::option::Option::None,
            low_priority: ::std::option::Option::None,
            client_message_id: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CFriendMessages_SendMessage_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CFriendMessages_SendMessage_Response {
    // message fields
    // @@protoc_insertion_point(field:CFriendMessages_SendMessage_Response.modified_message)
    pub modified_message: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CFriendMessages_SendMessage_Response.server_timestamp)
    pub server_timestamp: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CFriendMessages_SendMessage_Response.ordinal)
    pub ordinal: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CFriendMessages_SendMessage_Response.message_without_bb_code)
    pub message_without_bb_code: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CFriendMessages_SendMessage_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string modified_message = 1;

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

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

    pub fn has_modified_message(&self) -> bool {
        self.modified_message.is_some()
    }

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

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

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

    // optional uint32 server_timestamp = 2;

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

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

    pub fn has_server_timestamp(&self) -> bool {
        self.server_timestamp.is_some()
    }

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

    // optional uint32 ordinal = 3;

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

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

    pub fn has_ordinal(&self) -> bool {
        self.ordinal.is_some()
    }

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

    // optional string message_without_bb_code = 4;

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

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

    pub fn has_message_without_bb_code(&self) -> bool {
        self.message_without_bb_code.is_some()
    }

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for CFriendMessages_SendMessage_Response {
    const NAME: &'static str = "CFriendMessages_SendMessage_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.modified_message = ::std::option::Option::Some(is.read_string()?);
                },
                16 => {
                    self.server_timestamp = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.ordinal = ::std::option::Option::Some(is.read_uint32()?);
                },
                34 => {
                    self.message_without_bb_code = ::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.modified_message.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.server_timestamp {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.ordinal {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.message_without_bb_code.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.modified_message.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.server_timestamp {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.ordinal {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.message_without_bb_code.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() -> CFriendMessages_SendMessage_Response {
        CFriendMessages_SendMessage_Response::new()
    }

    fn clear(&mut self) {
        self.modified_message = ::std::option::Option::None;
        self.server_timestamp = ::std::option::Option::None;
        self.ordinal = ::std::option::Option::None;
        self.message_without_bb_code = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CFriendMessages_SendMessage_Response {
        static instance: CFriendMessages_SendMessage_Response = CFriendMessages_SendMessage_Response {
            modified_message: ::std::option::Option::None,
            server_timestamp: ::std::option::Option::None,
            ordinal: ::std::option::Option::None,
            message_without_bb_code: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional fixed64 steamid_partner = 1;

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

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

    pub fn has_steamid_partner(&self) -> bool {
        self.steamid_partner.is_some()
    }

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

    // optional uint32 timestamp = 2;

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

impl ::steam_vent_proto_common::protobuf::Message for CFriendMessages_AckMessage_Notification {
    const NAME: &'static str = "CFriendMessages_AckMessage_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 {
                9 => {
                    self.steamid_partner = ::std::option::Option::Some(is.read_fixed64()?);
                },
                16 => {
                    self.timestamp = ::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.steamid_partner {
            my_size += 1 + 8;
        }
        if let Some(v) = self.timestamp {
            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.steamid_partner {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.timestamp {
            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() -> CFriendMessages_AckMessage_Notification {
        CFriendMessages_AckMessage_Notification::new()
    }

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

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

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

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

impl CFriendMessages_IsInFriendsUIBeta_Request {
    pub fn new() -> CFriendMessages_IsInFriendsUIBeta_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);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CFriendMessages_IsInFriendsUIBeta_Request {
    const NAME: &'static str = "CFriendMessages_IsInFriendsUIBeta_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()?);
                },
                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;
        }
        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)?;
        }
        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() -> CFriendMessages_IsInFriendsUIBeta_Request {
        CFriendMessages_IsInFriendsUIBeta_Request::new()
    }

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

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

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

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

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

    // optional bool online_in_friendsui = 1;

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

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

    pub fn has_online_in_friendsui(&self) -> bool {
        self.online_in_friendsui.is_some()
    }

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

    // optional bool has_used_friendsui = 2;

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

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

    pub fn has_has_used_friendsui(&self) -> bool {
        self.has_used_friendsui.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CFriendMessages_IsInFriendsUIBeta_Response {
    const NAME: &'static str = "CFriendMessages_IsInFriendsUIBeta_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.online_in_friendsui = ::std::option::Option::Some(is.read_bool()?);
                },
                16 => {
                    self.has_used_friendsui = ::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.online_in_friendsui {
            my_size += 1 + 1;
        }
        if let Some(v) = self.has_used_friendsui {
            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.online_in_friendsui {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.has_used_friendsui {
            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() -> CFriendMessages_IsInFriendsUIBeta_Response {
        CFriendMessages_IsInFriendsUIBeta_Response::new()
    }

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

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

// @@protoc_insertion_point(message:CFriendMessages_UpdateMessageReaction_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CFriendMessages_UpdateMessageReaction_Request {
    // message fields
    // @@protoc_insertion_point(field:CFriendMessages_UpdateMessageReaction_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CFriendMessages_UpdateMessageReaction_Request.server_timestamp)
    pub server_timestamp: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CFriendMessages_UpdateMessageReaction_Request.ordinal)
    pub ordinal: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CFriendMessages_UpdateMessageReaction_Request.reaction_type)
    pub reaction_type: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<EMessageReactionType>>,
    // @@protoc_insertion_point(field:CFriendMessages_UpdateMessageReaction_Request.reaction)
    pub reaction: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CFriendMessages_UpdateMessageReaction_Request.is_add)
    pub is_add: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CFriendMessages_UpdateMessageReaction_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl CFriendMessages_UpdateMessageReaction_Request {
    pub fn new() -> CFriendMessages_UpdateMessageReaction_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 server_timestamp = 2;

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

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

    pub fn has_server_timestamp(&self) -> bool {
        self.server_timestamp.is_some()
    }

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

    // optional uint32 ordinal = 3;

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

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

    pub fn has_ordinal(&self) -> bool {
        self.ordinal.is_some()
    }

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

    // optional .EMessageReactionType reaction_type = 4;

    pub fn reaction_type(&self) -> EMessageReactionType {
        match self.reaction_type {
            Some(e) => e.enum_value_or(EMessageReactionType::k_EMessageReactionType_Invalid),
            None => EMessageReactionType::k_EMessageReactionType_Invalid,
        }
    }

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

    pub fn has_reaction_type(&self) -> bool {
        self.reaction_type.is_some()
    }

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

    // optional string reaction = 5;

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

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

    pub fn has_reaction(&self) -> bool {
        self.reaction.is_some()
    }

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

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

    // optional bool is_add = 6;

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

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

    pub fn has_is_add(&self) -> bool {
        self.is_add.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CFriendMessages_UpdateMessageReaction_Request {
    const NAME: &'static str = "CFriendMessages_UpdateMessageReaction_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.server_timestamp = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.ordinal = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.reaction_type = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                42 => {
                    self.reaction = ::std::option::Option::Some(is.read_string()?);
                },
                48 => {
                    self.is_add = ::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.steamid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.server_timestamp {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.ordinal {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.reaction_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v.value());
        }
        if let Some(v) = self.reaction.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &v);
        }
        if let Some(v) = self.is_add {
            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.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.server_timestamp {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.ordinal {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.reaction_type {
            os.write_enum(4, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.reaction.as_ref() {
            os.write_string(5, v)?;
        }
        if let Some(v) = self.is_add {
            os.write_bool(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() -> CFriendMessages_UpdateMessageReaction_Request {
        CFriendMessages_UpdateMessageReaction_Request::new()
    }

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.server_timestamp = ::std::option::Option::None;
        self.ordinal = ::std::option::Option::None;
        self.reaction_type = ::std::option::Option::None;
        self.reaction = ::std::option::Option::None;
        self.is_add = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CFriendMessages_UpdateMessageReaction_Request {
        static instance: CFriendMessages_UpdateMessageReaction_Request = CFriendMessages_UpdateMessageReaction_Request {
            steamid: ::std::option::Option::None,
            server_timestamp: ::std::option::Option::None,
            ordinal: ::std::option::Option::None,
            reaction_type: ::std::option::Option::None,
            reaction: ::std::option::Option::None,
            is_add: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for CFriendMessages_UpdateMessageReaction_Response {
    const NAME: &'static str = "CFriendMessages_UpdateMessageReaction_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.reactors)?;
                },
                8 => {
                    self.reactors.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.reactors {
            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.reactors {
            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() -> CFriendMessages_UpdateMessageReaction_Response {
        CFriendMessages_UpdateMessageReaction_Response::new()
    }

    fn clear(&mut self) {
        self.reactors.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CFriendMessages_UpdateMessageReaction_Response {
        static instance: CFriendMessages_UpdateMessageReaction_Response = CFriendMessages_UpdateMessageReaction_Response {
            reactors: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CFriendMessages_ReportMessage_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CFriendMessages_ReportMessage_Request {
    // message fields
    // @@protoc_insertion_point(field:CFriendMessages_ReportMessage_Request.steamid_from)
    pub steamid_from: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CFriendMessages_ReportMessage_Request.steamid_to)
    pub steamid_to: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CFriendMessages_ReportMessage_Request.timestamp)
    pub timestamp: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CFriendMessages_ReportMessage_Request.ordinal)
    pub ordinal: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CFriendMessages_ReportMessage_Request.report_reason)
    pub report_reason: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::enums::EContentReportReason>>,
    // @@protoc_insertion_point(field:CFriendMessages_ReportMessage_Request.report_text)
    pub report_text: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CFriendMessages_ReportMessage_Request.language)
    pub language: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CFriendMessages_ReportMessage_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed64 steamid_from = 1;

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

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

    pub fn has_steamid_from(&self) -> bool {
        self.steamid_from.is_some()
    }

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

    // optional fixed64 steamid_to = 2;

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

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

    pub fn has_steamid_to(&self) -> bool {
        self.steamid_to.is_some()
    }

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

    // optional uint32 timestamp = 3;

    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 uint32 ordinal = 4;

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

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

    pub fn has_ordinal(&self) -> bool {
        self.ordinal.is_some()
    }

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

    // optional .EContentReportReason report_reason = 5;

    pub fn report_reason(&self) -> super::enums::EContentReportReason {
        match self.report_reason {
            Some(e) => e.enum_value_or(super::enums::EContentReportReason::k_EContentReportReason_Invalid),
            None => super::enums::EContentReportReason::k_EContentReportReason_Invalid,
        }
    }

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

    pub fn has_report_reason(&self) -> bool {
        self.report_reason.is_some()
    }

    // Param is passed by value, moved
    pub fn set_report_reason(&mut self, v: super::enums::EContentReportReason) {
        self.report_reason = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional string report_text = 6;

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

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

    pub fn has_report_text(&self) -> bool {
        self.report_text.is_some()
    }

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

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

    // optional string language = 7;

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

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

    pub fn has_language(&self) -> bool {
        self.language.is_some()
    }

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

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

impl ::steam_vent_proto_common::protobuf::Message for CFriendMessages_ReportMessage_Request {
    const NAME: &'static str = "CFriendMessages_ReportMessage_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_from = ::std::option::Option::Some(is.read_fixed64()?);
                },
                17 => {
                    self.steamid_to = ::std::option::Option::Some(is.read_fixed64()?);
                },
                24 => {
                    self.timestamp = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.ordinal = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.report_reason = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                50 => {
                    self.report_text = ::std::option::Option::Some(is.read_string()?);
                },
                58 => {
                    self.language = ::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.steamid_from {
            my_size += 1 + 8;
        }
        if let Some(v) = self.steamid_to {
            my_size += 1 + 8;
        }
        if let Some(v) = self.timestamp {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.ordinal {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.report_reason {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v.value());
        }
        if let Some(v) = self.report_text.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_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.steamid_from {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.steamid_to {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.timestamp {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.ordinal {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.report_reason {
            os.write_enum(5, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.report_text.as_ref() {
            os.write_string(6, v)?;
        }
        if let Some(v) = self.language.as_ref() {
            os.write_string(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() -> CFriendMessages_ReportMessage_Request {
        CFriendMessages_ReportMessage_Request::new()
    }

    fn clear(&mut self) {
        self.steamid_from = ::std::option::Option::None;
        self.steamid_to = ::std::option::Option::None;
        self.timestamp = ::std::option::Option::None;
        self.ordinal = ::std::option::Option::None;
        self.report_reason = ::std::option::Option::None;
        self.report_text = ::std::option::Option::None;
        self.language = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CFriendMessages_ReportMessage_Request {
        static instance: CFriendMessages_ReportMessage_Request = CFriendMessages_ReportMessage_Request {
            steamid_from: ::std::option::Option::None,
            steamid_to: ::std::option::Option::None,
            timestamp: ::std::option::Option::None,
            ordinal: ::std::option::Option::None,
            report_reason: ::std::option::Option::None,
            report_text: ::std::option::Option::None,
            language: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CFriendMessages_ReportMessage_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CFriendMessages_ReportMessage_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CFriendMessages_ReportMessage_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

impl ::steam_vent_proto_common::protobuf::Message for CFriendMessages_ReportMessage_Response {
    const NAME: &'static str = "CFriendMessages_ReportMessage_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 {
                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() -> CFriendMessages_ReportMessage_Response {
        CFriendMessages_ReportMessage_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CFriendMessages_ReportMessage_Response {
        static instance: CFriendMessages_ReportMessage_Response = CFriendMessages_ReportMessage_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CFriendMessages_ResolveReport_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CFriendMessages_ResolveReport_Request {
    // message fields
    // @@protoc_insertion_point(field:CFriendMessages_ResolveReport_Request.steamid_from)
    pub steamid_from: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CFriendMessages_ResolveReport_Request.steamid_to)
    pub steamid_to: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CFriendMessages_ResolveReport_Request.subject_group_id)
    pub subject_group_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CFriendMessages_ResolveReport_Request.subject_id)
    pub subject_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CFriendMessages_ResolveReport_Request.resolution)
    pub resolution: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::enums::EContentReportResolution>>,
    // @@protoc_insertion_point(field:CFriendMessages_ResolveReport_Request.reason)
    pub reason: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::enums::EContentReportReason>>,
    // special fields
    // @@protoc_insertion_point(special_field:CFriendMessages_ResolveReport_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed64 steamid_from = 1;

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

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

    pub fn has_steamid_from(&self) -> bool {
        self.steamid_from.is_some()
    }

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

    // optional fixed64 steamid_to = 2;

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

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

    pub fn has_steamid_to(&self) -> bool {
        self.steamid_to.is_some()
    }

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

    // optional uint64 subject_group_id = 3;

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

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

    pub fn has_subject_group_id(&self) -> bool {
        self.subject_group_id.is_some()
    }

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

    // optional uint64 subject_id = 4;

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

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

    pub fn has_subject_id(&self) -> bool {
        self.subject_id.is_some()
    }

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

    // optional .EContentReportResolution resolution = 5;

    pub fn resolution(&self) -> super::enums::EContentReportResolution {
        match self.resolution {
            Some(e) => e.enum_value_or(super::enums::EContentReportResolution::k_EContentReportResolution_Unresolved),
            None => super::enums::EContentReportResolution::k_EContentReportResolution_Unresolved,
        }
    }

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

    pub fn has_resolution(&self) -> bool {
        self.resolution.is_some()
    }

    // Param is passed by value, moved
    pub fn set_resolution(&mut self, v: super::enums::EContentReportResolution) {
        self.resolution = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional .EContentReportReason reason = 6;

    pub fn reason(&self) -> super::enums::EContentReportReason {
        match self.reason {
            Some(e) => e.enum_value_or(super::enums::EContentReportReason::k_EContentReportReason_Invalid),
            None => super::enums::EContentReportReason::k_EContentReportReason_Invalid,
        }
    }

    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: super::enums::EContentReportReason) {
        self.reason = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CFriendMessages_ResolveReport_Request {
    const NAME: &'static str = "CFriendMessages_ResolveReport_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_from = ::std::option::Option::Some(is.read_fixed64()?);
                },
                17 => {
                    self.steamid_to = ::std::option::Option::Some(is.read_fixed64()?);
                },
                24 => {
                    self.subject_group_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                32 => {
                    self.subject_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                40 => {
                    self.resolution = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                48 => {
                    self.reason = ::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.steamid_from {
            my_size += 1 + 8;
        }
        if let Some(v) = self.steamid_to {
            my_size += 1 + 8;
        }
        if let Some(v) = self.subject_group_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
        }
        if let Some(v) = self.subject_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(4, v);
        }
        if let Some(v) = self.resolution {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v.value());
        }
        if let Some(v) = self.reason {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(6, 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.steamid_from {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.steamid_to {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.subject_group_id {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.subject_id {
            os.write_uint64(4, v)?;
        }
        if let Some(v) = self.resolution {
            os.write_enum(5, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.reason {
            os.write_enum(6, ::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() -> CFriendMessages_ResolveReport_Request {
        CFriendMessages_ResolveReport_Request::new()
    }

    fn clear(&mut self) {
        self.steamid_from = ::std::option::Option::None;
        self.steamid_to = ::std::option::Option::None;
        self.subject_group_id = ::std::option::Option::None;
        self.subject_id = ::std::option::Option::None;
        self.resolution = ::std::option::Option::None;
        self.reason = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CFriendMessages_ResolveReport_Request {
        static instance: CFriendMessages_ResolveReport_Request = CFriendMessages_ResolveReport_Request {
            steamid_from: ::std::option::Option::None,
            steamid_to: ::std::option::Option::None,
            subject_group_id: ::std::option::Option::None,
            subject_id: ::std::option::Option::None,
            resolution: ::std::option::Option::None,
            reason: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CFriendMessages_ResolveReport_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CFriendMessages_ResolveReport_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CFriendMessages_ResolveReport_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

impl ::steam_vent_proto_common::protobuf::Message for CFriendMessages_ResolveReport_Response {
    const NAME: &'static str = "CFriendMessages_ResolveReport_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 {
                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() -> CFriendMessages_ResolveReport_Response {
        CFriendMessages_ResolveReport_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CFriendMessages_ResolveReport_Response {
        static instance: CFriendMessages_ResolveReport_Response = CFriendMessages_ResolveReport_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CFriendMessages_IncomingMessage_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CFriendMessages_IncomingMessage_Notification {
    // message fields
    // @@protoc_insertion_point(field:CFriendMessages_IncomingMessage_Notification.steamid_friend)
    pub steamid_friend: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CFriendMessages_IncomingMessage_Notification.chat_entry_type)
    pub chat_entry_type: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CFriendMessages_IncomingMessage_Notification.from_limited_account)
    pub from_limited_account: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CFriendMessages_IncomingMessage_Notification.message)
    pub message: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CFriendMessages_IncomingMessage_Notification.rtime32_server_timestamp)
    pub rtime32_server_timestamp: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CFriendMessages_IncomingMessage_Notification.ordinal)
    pub ordinal: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CFriendMessages_IncomingMessage_Notification.local_echo)
    pub local_echo: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CFriendMessages_IncomingMessage_Notification.message_no_bbcode)
    pub message_no_bbcode: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CFriendMessages_IncomingMessage_Notification.low_priority)
    pub low_priority: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CFriendMessages_IncomingMessage_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed64 steamid_friend = 1;

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

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

    pub fn has_steamid_friend(&self) -> bool {
        self.steamid_friend.is_some()
    }

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

    // optional int32 chat_entry_type = 2;

    pub fn chat_entry_type(&self) -> i32 {
        self.chat_entry_type.unwrap_or(0)
    }

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

    pub fn has_chat_entry_type(&self) -> bool {
        self.chat_entry_type.is_some()
    }

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

    // optional bool from_limited_account = 3;

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

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

    pub fn has_from_limited_account(&self) -> bool {
        self.from_limited_account.is_some()
    }

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

    // optional string message = 4;

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

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

    pub fn has_message(&self) -> bool {
        self.message.is_some()
    }

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

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

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

    // optional fixed32 rtime32_server_timestamp = 5;

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

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

    pub fn has_rtime32_server_timestamp(&self) -> bool {
        self.rtime32_server_timestamp.is_some()
    }

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

    // optional uint32 ordinal = 6;

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

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

    pub fn has_ordinal(&self) -> bool {
        self.ordinal.is_some()
    }

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

    // optional bool local_echo = 7;

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

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

    pub fn has_local_echo(&self) -> bool {
        self.local_echo.is_some()
    }

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

    // optional string message_no_bbcode = 8;

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

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

    pub fn has_message_no_bbcode(&self) -> bool {
        self.message_no_bbcode.is_some()
    }

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

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

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

    // optional bool low_priority = 9;

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

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

    pub fn has_low_priority(&self) -> bool {
        self.low_priority.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CFriendMessages_IncomingMessage_Notification {
    const NAME: &'static str = "CFriendMessages_IncomingMessage_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 {
                9 => {
                    self.steamid_friend = ::std::option::Option::Some(is.read_fixed64()?);
                },
                16 => {
                    self.chat_entry_type = ::std::option::Option::Some(is.read_int32()?);
                },
                24 => {
                    self.from_limited_account = ::std::option::Option::Some(is.read_bool()?);
                },
                34 => {
                    self.message = ::std::option::Option::Some(is.read_string()?);
                },
                45 => {
                    self.rtime32_server_timestamp = ::std::option::Option::Some(is.read_fixed32()?);
                },
                48 => {
                    self.ordinal = ::std::option::Option::Some(is.read_uint32()?);
                },
                56 => {
                    self.local_echo = ::std::option::Option::Some(is.read_bool()?);
                },
                66 => {
                    self.message_no_bbcode = ::std::option::Option::Some(is.read_string()?);
                },
                72 => {
                    self.low_priority = ::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.steamid_friend {
            my_size += 1 + 8;
        }
        if let Some(v) = self.chat_entry_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
        }
        if let Some(v) = self.from_limited_account {
            my_size += 1 + 1;
        }
        if let Some(v) = self.message.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.rtime32_server_timestamp {
            my_size += 1 + 4;
        }
        if let Some(v) = self.ordinal {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.local_echo {
            my_size += 1 + 1;
        }
        if let Some(v) = self.message_no_bbcode.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(8, &v);
        }
        if let Some(v) = self.low_priority {
            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.steamid_friend {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.chat_entry_type {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.from_limited_account {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.message.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.rtime32_server_timestamp {
            os.write_fixed32(5, v)?;
        }
        if let Some(v) = self.ordinal {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.local_echo {
            os.write_bool(7, v)?;
        }
        if let Some(v) = self.message_no_bbcode.as_ref() {
            os.write_string(8, v)?;
        }
        if let Some(v) = self.low_priority {
            os.write_bool(9, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.steamid_friend = ::std::option::Option::None;
        self.chat_entry_type = ::std::option::Option::None;
        self.from_limited_account = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.rtime32_server_timestamp = ::std::option::Option::None;
        self.ordinal = ::std::option::Option::None;
        self.local_echo = ::std::option::Option::None;
        self.message_no_bbcode = ::std::option::Option::None;
        self.low_priority = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CFriendMessages_IncomingMessage_Notification {
        static instance: CFriendMessages_IncomingMessage_Notification = CFriendMessages_IncomingMessage_Notification {
            steamid_friend: ::std::option::Option::None,
            chat_entry_type: ::std::option::Option::None,
            from_limited_account: ::std::option::Option::None,
            message: ::std::option::Option::None,
            rtime32_server_timestamp: ::std::option::Option::None,
            ordinal: ::std::option::Option::None,
            local_echo: ::std::option::Option::None,
            message_no_bbcode: ::std::option::Option::None,
            low_priority: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CFriendMessages_MessageReaction_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CFriendMessages_MessageReaction_Notification {
    // message fields
    // @@protoc_insertion_point(field:CFriendMessages_MessageReaction_Notification.steamid_friend)
    pub steamid_friend: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CFriendMessages_MessageReaction_Notification.server_timestamp)
    pub server_timestamp: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CFriendMessages_MessageReaction_Notification.ordinal)
    pub ordinal: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CFriendMessages_MessageReaction_Notification.reactor)
    pub reactor: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CFriendMessages_MessageReaction_Notification.reaction_type)
    pub reaction_type: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<EMessageReactionType>>,
    // @@protoc_insertion_point(field:CFriendMessages_MessageReaction_Notification.reaction)
    pub reaction: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CFriendMessages_MessageReaction_Notification.is_add)
    pub is_add: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CFriendMessages_MessageReaction_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed64 steamid_friend = 1;

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

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

    pub fn has_steamid_friend(&self) -> bool {
        self.steamid_friend.is_some()
    }

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

    // optional uint32 server_timestamp = 2;

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

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

    pub fn has_server_timestamp(&self) -> bool {
        self.server_timestamp.is_some()
    }

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

    // optional uint32 ordinal = 3;

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

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

    pub fn has_ordinal(&self) -> bool {
        self.ordinal.is_some()
    }

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

    // optional fixed64 reactor = 4;

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

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

    pub fn has_reactor(&self) -> bool {
        self.reactor.is_some()
    }

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

    // optional .EMessageReactionType reaction_type = 5;

    pub fn reaction_type(&self) -> EMessageReactionType {
        match self.reaction_type {
            Some(e) => e.enum_value_or(EMessageReactionType::k_EMessageReactionType_Invalid),
            None => EMessageReactionType::k_EMessageReactionType_Invalid,
        }
    }

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

    pub fn has_reaction_type(&self) -> bool {
        self.reaction_type.is_some()
    }

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

    // optional string reaction = 6;

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

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

    pub fn has_reaction(&self) -> bool {
        self.reaction.is_some()
    }

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

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

    // optional bool is_add = 7;

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

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

    pub fn has_is_add(&self) -> bool {
        self.is_add.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CFriendMessages_MessageReaction_Notification {
    const NAME: &'static str = "CFriendMessages_MessageReaction_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 {
                9 => {
                    self.steamid_friend = ::std::option::Option::Some(is.read_fixed64()?);
                },
                16 => {
                    self.server_timestamp = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.ordinal = ::std::option::Option::Some(is.read_uint32()?);
                },
                33 => {
                    self.reactor = ::std::option::Option::Some(is.read_fixed64()?);
                },
                40 => {
                    self.reaction_type = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                50 => {
                    self.reaction = ::std::option::Option::Some(is.read_string()?);
                },
                56 => {
                    self.is_add = ::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.steamid_friend {
            my_size += 1 + 8;
        }
        if let Some(v) = self.server_timestamp {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.ordinal {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.reactor {
            my_size += 1 + 8;
        }
        if let Some(v) = self.reaction_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v.value());
        }
        if let Some(v) = self.reaction.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.is_add {
            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.steamid_friend {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.server_timestamp {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.ordinal {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.reactor {
            os.write_fixed64(4, v)?;
        }
        if let Some(v) = self.reaction_type {
            os.write_enum(5, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.reaction.as_ref() {
            os.write_string(6, v)?;
        }
        if let Some(v) = self.is_add {
            os.write_bool(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() -> CFriendMessages_MessageReaction_Notification {
        CFriendMessages_MessageReaction_Notification::new()
    }

    fn clear(&mut self) {
        self.steamid_friend = ::std::option::Option::None;
        self.server_timestamp = ::std::option::Option::None;
        self.ordinal = ::std::option::Option::None;
        self.reactor = ::std::option::Option::None;
        self.reaction_type = ::std::option::Option::None;
        self.reaction = ::std::option::Option::None;
        self.is_add = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CFriendMessages_MessageReaction_Notification {
        static instance: CFriendMessages_MessageReaction_Notification = CFriendMessages_MessageReaction_Notification {
            steamid_friend: ::std::option::Option::None,
            server_timestamp: ::std::option::Option::None,
            ordinal: ::std::option::Option::None,
            reactor: ::std::option::Option::None,
            reaction_type: ::std::option::Option::None,
            reaction: ::std::option::Option::None,
            is_add: ::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:EMessageReactionType)
pub enum EMessageReactionType {
    // @@protoc_insertion_point(enum_value:EMessageReactionType.k_EMessageReactionType_Invalid)
    k_EMessageReactionType_Invalid = 0,
    // @@protoc_insertion_point(enum_value:EMessageReactionType.k_EMessageReactionType_Emoticon)
    k_EMessageReactionType_Emoticon = 1,
    // @@protoc_insertion_point(enum_value:EMessageReactionType.k_EMessageReactionType_Sticker)
    k_EMessageReactionType_Sticker = 2,
}

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

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

    fn from_i32(value: i32) -> ::std::option::Option<EMessageReactionType> {
        match value {
            0 => ::std::option::Option::Some(EMessageReactionType::k_EMessageReactionType_Invalid),
            1 => ::std::option::Option::Some(EMessageReactionType::k_EMessageReactionType_Emoticon),
            2 => ::std::option::Option::Some(EMessageReactionType::k_EMessageReactionType_Sticker),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<EMessageReactionType> {
        match str {
            "k_EMessageReactionType_Invalid" => ::std::option::Option::Some(EMessageReactionType::k_EMessageReactionType_Invalid),
            "k_EMessageReactionType_Emoticon" => ::std::option::Option::Some(EMessageReactionType::k_EMessageReactionType_Emoticon),
            "k_EMessageReactionType_Sticker" => ::std::option::Option::Some(EMessageReactionType::k_EMessageReactionType_Sticker),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [EMessageReactionType] = &[
        EMessageReactionType::k_EMessageReactionType_Invalid,
        EMessageReactionType::k_EMessageReactionType_Emoticon,
        EMessageReactionType::k_EMessageReactionType_Sticker,
    ];
}

impl ::std::default::Default for EMessageReactionType {
    fn default() -> Self {
        EMessageReactionType::k_EMessageReactionType_Invalid
    }
}



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::enums::*;
impl ::steam_vent_proto_common::RpcMessage
for CFriendMessages_GetRecentMessages_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 CFriendMessages_GetRecentMessages_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 CFriendsMessages_GetActiveMessageSessions_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 CFriendsMessages_GetActiveMessageSessions_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 CFriendMessages_SendMessage_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 CFriendMessages_SendMessage_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 CFriendMessages_AckMessage_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
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CFriendMessages_IsInFriendsUIBeta_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 CFriendMessages_IsInFriendsUIBeta_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 CFriendMessages_UpdateMessageReaction_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 CFriendMessages_UpdateMessageReaction_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 CFriendMessages_ReportMessage_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 CFriendMessages_ReportMessage_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 CFriendMessages_ResolveReport_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 CFriendMessages_ResolveReport_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 CFriendMessages_IncomingMessage_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
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CFriendMessages_MessageReaction_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 FriendMessages {}
impl ::steam_vent_proto_common::RpcService for FriendMessages {
    const SERVICE_NAME: &'static str = "FriendMessages";
}
///
struct FriendMessagesClient {}
impl ::steam_vent_proto_common::RpcService for FriendMessagesClient {
    const SERVICE_NAME: &'static str = "FriendMessagesClient";
}
impl ::steam_vent_proto_common::RpcMethod for CFriendMessages_AckMessage_Notification {
    const METHOD_NAME: &'static str = "FriendMessages.AckMessage#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CFriendMessages_GetRecentMessages_Request {
    const METHOD_NAME: &'static str = "FriendMessages.GetRecentMessages#1";
    type Response = CFriendMessages_GetRecentMessages_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CFriendMessages_IncomingMessage_Notification {
    const METHOD_NAME: &'static str = "FriendMessagesClient.IncomingMessage#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CFriendMessages_IsInFriendsUIBeta_Request {
    const METHOD_NAME: &'static str = "FriendMessages.IsInFriendsUIBeta#1";
    type Response = CFriendMessages_IsInFriendsUIBeta_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CFriendMessages_MessageReaction_Notification {
    const METHOD_NAME: &'static str = "FriendMessagesClient.MessageReaction#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CFriendMessages_ReportMessage_Request {
    const METHOD_NAME: &'static str = "FriendMessages.ReportMessage#1";
    type Response = CFriendMessages_ReportMessage_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CFriendMessages_ResolveReport_Request {
    const METHOD_NAME: &'static str = "FriendMessages.ResolveReport#1";
    type Response = CFriendMessages_ResolveReport_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CFriendMessages_SendMessage_Request {
    const METHOD_NAME: &'static str = "FriendMessages.SendMessage#1";
    type Response = CFriendMessages_SendMessage_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CFriendMessages_UpdateMessageReaction_Request {
    const METHOD_NAME: &'static str = "FriendMessages.UpdateMessageReaction#1";
    type Response = CFriendMessages_UpdateMessageReaction_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CFriendsMessages_GetActiveMessageSessions_Request {
    const METHOD_NAME: &'static str = "FriendMessages.GetActiveMessageSessions#1";
    type Response = CFriendsMessages_GetActiveMessageSessions_Response;
}
