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

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

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

    // optional uint64 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 CPlayer_GetRecentPlaytimeSessionsForChild_Request {
    const NAME: &'static str = "CPlayer_GetRecentPlaytimeSessionsForChild_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.steamid = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetRecentPlaytimeSessionsForChild_Response {
    const NAME: &'static str = "CPlayer_GetRecentPlaytimeSessionsForChild_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.sessions.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.sessions {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

/// Nested message and enums of message `CPlayer_GetRecentPlaytimeSessionsForChild_Response`
pub mod cplayer_get_recent_playtime_sessions_for_child_response {
    // @@protoc_insertion_point(message:CPlayer_GetRecentPlaytimeSessionsForChild_Response.PlaytimeSession)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct PlaytimeSession {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetRecentPlaytimeSessionsForChild_Response.PlaytimeSession.time_start)
        pub time_start: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetRecentPlaytimeSessionsForChild_Response.PlaytimeSession.time_end)
        pub time_end: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetRecentPlaytimeSessionsForChild_Response.PlaytimeSession.appid)
        pub appid: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetRecentPlaytimeSessionsForChild_Response.PlaytimeSession.device_type)
        pub device_type: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetRecentPlaytimeSessionsForChild_Response.PlaytimeSession.disconnected)
        pub disconnected: ::std::option::Option<bool>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetRecentPlaytimeSessionsForChild_Response.PlaytimeSession.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional uint32 time_start = 1;

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

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

        pub fn has_time_start(&self) -> bool {
            self.time_start.is_some()
        }

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

        // optional uint32 time_end = 2;

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

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

        pub fn has_time_end(&self) -> bool {
            self.time_end.is_some()
        }

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

        // optional uint32 appid = 3;

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

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

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

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

        // optional uint32 device_type = 4;

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

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

        pub fn has_device_type(&self) -> bool {
            self.device_type.is_some()
        }

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

        // optional bool disconnected = 5;

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

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

        pub fn has_disconnected(&self) -> bool {
            self.disconnected.is_some()
        }

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

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

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

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.time_start = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    16 => {
                        self.time_end = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    24 => {
                        self.appid = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    32 => {
                        self.device_type = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    40 => {
                        self.disconnected = ::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.time_start {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
            }
            if let Some(v) = self.time_end {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
            }
            if let Some(v) = self.appid {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
            }
            if let Some(v) = self.device_type {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
            }
            if let Some(v) = self.disconnected {
                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.time_start {
                os.write_uint32(1, v)?;
            }
            if let Some(v) = self.time_end {
                os.write_uint32(2, v)?;
            }
            if let Some(v) = self.appid {
                os.write_uint32(3, v)?;
            }
            if let Some(v) = self.device_type {
                os.write_uint32(4, v)?;
            }
            if let Some(v) = self.disconnected {
                os.write_bool(5, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

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

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

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

        fn clear(&mut self) {
            self.time_start = ::std::option::Option::None;
            self.time_end = ::std::option::Option::None;
            self.appid = ::std::option::Option::None;
            self.device_type = ::std::option::Option::None;
            self.disconnected = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static PlaytimeSession {
            static instance: PlaytimeSession = PlaytimeSession {
                time_start: ::std::option::Option::None,
                time_end: ::std::option::Option::None,
                appid: ::std::option::Option::None,
                device_type: ::std::option::Option::None,
                disconnected: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    is.read_repeated_packed_uint64_into(&mut self.steamids)?;
                },
                8 => {
                    self.steamids.push(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.steamids {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.steamids {
            os.write_uint64(1, *v)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

    fn is_initialized(&self) -> bool {
        for v in &self.accounts {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.accounts {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

/// Nested message and enums of message `CPlayer_GetPlayerLinkDetails_Response`
pub mod cplayer_get_player_link_details_response {
    // @@protoc_insertion_point(message:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct PlayerLinkDetails {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.public_data)
        pub public_data: ::steam_vent_proto_common::protobuf::MessageField<player_link_details::AccountPublicData>,
        // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.private_data)
        pub private_data: ::steam_vent_proto_common::protobuf::MessageField<player_link_details::AccountPrivateData>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

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

        fn is_initialized(&self) -> bool {
            for v in &self.public_data {
                if !v.is_initialized() {
                    return false;
                }
            };
            for v in &self.private_data {
                if !v.is_initialized() {
                    return false;
                }
            };
            true
        }

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.public_data)?;
                    },
                    18 => {
                        ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.private_data)?;
                    },
                    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.public_data.as_ref() {
                let len = v.compute_size();
                my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
            }
            if let Some(v) = self.private_data.as_ref() {
                let len = v.compute_size();
                my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

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

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

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

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

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

        fn default_instance() -> &'static PlayerLinkDetails {
            static instance: PlayerLinkDetails = PlayerLinkDetails {
                public_data: ::steam_vent_proto_common::protobuf::MessageField::none(),
                private_data: ::steam_vent_proto_common::protobuf::MessageField::none(),
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `PlayerLinkDetails`
    pub mod player_link_details {
        // @@protoc_insertion_point(message:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPublicData)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct AccountPublicData {
            // message fields
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPublicData.steamid)
            pub steamid: ::std::option::Option<u64>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPublicData.visibility_state)
            pub visibility_state: ::std::option::Option<i32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPublicData.privacy_state)
            pub privacy_state: ::std::option::Option<i32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPublicData.profile_state)
            pub profile_state: ::std::option::Option<i32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPublicData.ban_expires_time)
            pub ban_expires_time: ::std::option::Option<u32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPublicData.account_flags)
            pub account_flags: ::std::option::Option<u32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPublicData.sha_digest_avatar)
            pub sha_digest_avatar: ::std::option::Option<::std::vec::Vec<u8>>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPublicData.persona_name)
            pub persona_name: ::std::option::Option<::std::string::String>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPublicData.profile_url)
            pub profile_url: ::std::option::Option<::std::string::String>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPublicData.content_country_restricted)
            pub content_country_restricted: ::std::option::Option<bool>,
            // special fields
            // @@protoc_insertion_point(special_field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPublicData.special_fields)
            pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
        }

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

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

            // required 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 visibility_state = 2;

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

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

            pub fn has_visibility_state(&self) -> bool {
                self.visibility_state.is_some()
            }

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

            // optional int32 privacy_state = 3;

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

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

            pub fn has_privacy_state(&self) -> bool {
                self.privacy_state.is_some()
            }

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

            // optional int32 profile_state = 4;

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

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

            pub fn has_profile_state(&self) -> bool {
                self.profile_state.is_some()
            }

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

            // optional uint32 ban_expires_time = 7;

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

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

            pub fn has_ban_expires_time(&self) -> bool {
                self.ban_expires_time.is_some()
            }

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

            // optional uint32 account_flags = 8;

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

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

            pub fn has_account_flags(&self) -> bool {
                self.account_flags.is_some()
            }

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

            // optional bytes sha_digest_avatar = 9;

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

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

            pub fn has_sha_digest_avatar(&self) -> bool {
                self.sha_digest_avatar.is_some()
            }

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

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

            // optional string persona_name = 10;

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

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

            pub fn has_persona_name(&self) -> bool {
                self.persona_name.is_some()
            }

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

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

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

            // optional string profile_url = 11;

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

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

            pub fn has_profile_url(&self) -> bool {
                self.profile_url.is_some()
            }

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

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

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

            // optional bool content_country_restricted = 12;

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

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

            pub fn has_content_country_restricted(&self) -> bool {
                self.content_country_restricted.is_some()
            }

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

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

            fn is_initialized(&self) -> bool {
                if self.steamid.is_none() {
                    return false;
                }
                true
            }

            fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
                while let Some(tag) = is.read_raw_tag_or_eof()? {
                    match tag {
                        9 => {
                            self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                        },
                        16 => {
                            self.visibility_state = ::std::option::Option::Some(is.read_int32()?);
                        },
                        24 => {
                            self.privacy_state = ::std::option::Option::Some(is.read_int32()?);
                        },
                        32 => {
                            self.profile_state = ::std::option::Option::Some(is.read_int32()?);
                        },
                        56 => {
                            self.ban_expires_time = ::std::option::Option::Some(is.read_uint32()?);
                        },
                        64 => {
                            self.account_flags = ::std::option::Option::Some(is.read_uint32()?);
                        },
                        74 => {
                            self.sha_digest_avatar = ::std::option::Option::Some(is.read_bytes()?);
                        },
                        82 => {
                            self.persona_name = ::std::option::Option::Some(is.read_string()?);
                        },
                        90 => {
                            self.profile_url = ::std::option::Option::Some(is.read_string()?);
                        },
                        96 => {
                            self.content_country_restricted = ::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.visibility_state {
                    my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
                }
                if let Some(v) = self.privacy_state {
                    my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v);
                }
                if let Some(v) = self.profile_state {
                    my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v);
                }
                if let Some(v) = self.ban_expires_time {
                    my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
                }
                if let Some(v) = self.account_flags {
                    my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, v);
                }
                if let Some(v) = self.sha_digest_avatar.as_ref() {
                    my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(9, &v);
                }
                if let Some(v) = self.persona_name.as_ref() {
                    my_size += ::steam_vent_proto_common::protobuf::rt::string_size(10, &v);
                }
                if let Some(v) = self.profile_url.as_ref() {
                    my_size += ::steam_vent_proto_common::protobuf::rt::string_size(11, &v);
                }
                if let Some(v) = self.content_country_restricted {
                    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.visibility_state {
                    os.write_int32(2, v)?;
                }
                if let Some(v) = self.privacy_state {
                    os.write_int32(3, v)?;
                }
                if let Some(v) = self.profile_state {
                    os.write_int32(4, v)?;
                }
                if let Some(v) = self.ban_expires_time {
                    os.write_uint32(7, v)?;
                }
                if let Some(v) = self.account_flags {
                    os.write_uint32(8, v)?;
                }
                if let Some(v) = self.sha_digest_avatar.as_ref() {
                    os.write_bytes(9, v)?;
                }
                if let Some(v) = self.persona_name.as_ref() {
                    os.write_string(10, v)?;
                }
                if let Some(v) = self.profile_url.as_ref() {
                    os.write_string(11, v)?;
                }
                if let Some(v) = self.content_country_restricted {
                    os.write_bool(12, v)?;
                }
                os.write_unknown_fields(self.special_fields.unknown_fields())?;
                ::std::result::Result::Ok(())
            }

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

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

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

            fn clear(&mut self) {
                self.steamid = ::std::option::Option::None;
                self.visibility_state = ::std::option::Option::None;
                self.privacy_state = ::std::option::Option::None;
                self.profile_state = ::std::option::Option::None;
                self.ban_expires_time = ::std::option::Option::None;
                self.account_flags = ::std::option::Option::None;
                self.sha_digest_avatar = ::std::option::Option::None;
                self.persona_name = ::std::option::Option::None;
                self.profile_url = ::std::option::Option::None;
                self.content_country_restricted = ::std::option::Option::None;
                self.special_fields.clear();
            }

            fn default_instance() -> &'static AccountPublicData {
                static instance: AccountPublicData = AccountPublicData {
                    steamid: ::std::option::Option::None,
                    visibility_state: ::std::option::Option::None,
                    privacy_state: ::std::option::Option::None,
                    profile_state: ::std::option::Option::None,
                    ban_expires_time: ::std::option::Option::None,
                    account_flags: ::std::option::Option::None,
                    sha_digest_avatar: ::std::option::Option::None,
                    persona_name: ::std::option::Option::None,
                    profile_url: ::std::option::Option::None,
                    content_country_restricted: ::std::option::Option::None,
                    special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }

        // @@protoc_insertion_point(message:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct AccountPrivateData {
            // message fields
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.persona_state)
            pub persona_state: ::std::option::Option<i32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.persona_state_flags)
            pub persona_state_flags: ::std::option::Option<u32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.time_created)
            pub time_created: ::std::option::Option<u32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.game_id)
            pub game_id: ::std::option::Option<u64>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.game_server_steam_id)
            pub game_server_steam_id: ::std::option::Option<u64>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.game_server_ip_address)
            pub game_server_ip_address: ::std::option::Option<u32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.game_server_port)
            pub game_server_port: ::std::option::Option<u32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.game_extra_info)
            pub game_extra_info: ::std::option::Option<::std::string::String>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.account_name)
            pub account_name: ::std::option::Option<::std::string::String>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.lobby_steam_id)
            pub lobby_steam_id: ::std::option::Option<u64>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.rich_presence_kv)
            pub rich_presence_kv: ::std::option::Option<::std::string::String>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.broadcast_session_id)
            pub broadcast_session_id: ::std::option::Option<u64>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.watching_broadcast_accountid)
            pub watching_broadcast_accountid: ::std::option::Option<u32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.watching_broadcast_appid)
            pub watching_broadcast_appid: ::std::option::Option<u32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.watching_broadcast_viewers)
            pub watching_broadcast_viewers: ::std::option::Option<u32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.watching_broadcast_title)
            pub watching_broadcast_title: ::std::option::Option<::std::string::String>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.last_logoff_time)
            pub last_logoff_time: ::std::option::Option<u32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.last_seen_online)
            pub last_seen_online: ::std::option::Option<u32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.game_os_type)
            pub game_os_type: ::std::option::Option<i32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.game_device_type)
            pub game_device_type: ::std::option::Option<i32>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.game_device_name)
            pub game_device_name: ::std::option::Option<::std::string::String>,
            // @@protoc_insertion_point(field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.game_is_private)
            pub game_is_private: ::std::option::Option<bool>,
            // special fields
            // @@protoc_insertion_point(special_field:CPlayer_GetPlayerLinkDetails_Response.PlayerLinkDetails.AccountPrivateData.special_fields)
            pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
        }

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

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

            // optional int32 persona_state = 1;

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

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

            pub fn has_persona_state(&self) -> bool {
                self.persona_state.is_some()
            }

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

            // optional uint32 persona_state_flags = 2;

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

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

            pub fn has_persona_state_flags(&self) -> bool {
                self.persona_state_flags.is_some()
            }

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

            // optional uint32 time_created = 3;

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

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

            pub fn has_time_created(&self) -> bool {
                self.time_created.is_some()
            }

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

            // optional fixed64 game_id = 4;

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

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

            pub fn has_game_id(&self) -> bool {
                self.game_id.is_some()
            }

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

            // optional fixed64 game_server_steam_id = 5;

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

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

            pub fn has_game_server_steam_id(&self) -> bool {
                self.game_server_steam_id.is_some()
            }

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

            // optional uint32 game_server_ip_address = 6;

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

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

            pub fn has_game_server_ip_address(&self) -> bool {
                self.game_server_ip_address.is_some()
            }

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

            // optional uint32 game_server_port = 7;

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

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

            pub fn has_game_server_port(&self) -> bool {
                self.game_server_port.is_some()
            }

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

            // optional string game_extra_info = 8;

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

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

            pub fn has_game_extra_info(&self) -> bool {
                self.game_extra_info.is_some()
            }

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

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

            // optional string account_name = 9;

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

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

            pub fn has_account_name(&self) -> bool {
                self.account_name.is_some()
            }

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

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

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

            // optional fixed64 lobby_steam_id = 10;

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

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

            pub fn has_lobby_steam_id(&self) -> bool {
                self.lobby_steam_id.is_some()
            }

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

            // optional string rich_presence_kv = 11;

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

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

            pub fn has_rich_presence_kv(&self) -> bool {
                self.rich_presence_kv.is_some()
            }

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

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

            // optional fixed64 broadcast_session_id = 12;

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

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

            pub fn has_broadcast_session_id(&self) -> bool {
                self.broadcast_session_id.is_some()
            }

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

            // optional uint32 watching_broadcast_accountid = 13;

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

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

            pub fn has_watching_broadcast_accountid(&self) -> bool {
                self.watching_broadcast_accountid.is_some()
            }

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

            // optional uint32 watching_broadcast_appid = 14;

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

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

            pub fn has_watching_broadcast_appid(&self) -> bool {
                self.watching_broadcast_appid.is_some()
            }

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

            // optional uint32 watching_broadcast_viewers = 15;

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

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

            pub fn has_watching_broadcast_viewers(&self) -> bool {
                self.watching_broadcast_viewers.is_some()
            }

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

            // optional string watching_broadcast_title = 16;

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

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

            pub fn has_watching_broadcast_title(&self) -> bool {
                self.watching_broadcast_title.is_some()
            }

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

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

            // optional uint32 last_logoff_time = 17;

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

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

            pub fn has_last_logoff_time(&self) -> bool {
                self.last_logoff_time.is_some()
            }

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

            // optional uint32 last_seen_online = 18;

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

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

            pub fn has_last_seen_online(&self) -> bool {
                self.last_seen_online.is_some()
            }

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

            // optional int32 game_os_type = 19;

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

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

            pub fn has_game_os_type(&self) -> bool {
                self.game_os_type.is_some()
            }

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

            // optional int32 game_device_type = 20;

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

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

            pub fn has_game_device_type(&self) -> bool {
                self.game_device_type.is_some()
            }

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

            // optional string game_device_name = 21;

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

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

            pub fn has_game_device_name(&self) -> bool {
                self.game_device_name.is_some()
            }

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

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

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

            // optional bool game_is_private = 22;

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

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

            pub fn has_game_is_private(&self) -> bool {
                self.game_is_private.is_some()
            }

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

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

            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.persona_state = ::std::option::Option::Some(is.read_int32()?);
                        },
                        16 => {
                            self.persona_state_flags = ::std::option::Option::Some(is.read_uint32()?);
                        },
                        24 => {
                            self.time_created = ::std::option::Option::Some(is.read_uint32()?);
                        },
                        33 => {
                            self.game_id = ::std::option::Option::Some(is.read_fixed64()?);
                        },
                        41 => {
                            self.game_server_steam_id = ::std::option::Option::Some(is.read_fixed64()?);
                        },
                        48 => {
                            self.game_server_ip_address = ::std::option::Option::Some(is.read_uint32()?);
                        },
                        56 => {
                            self.game_server_port = ::std::option::Option::Some(is.read_uint32()?);
                        },
                        66 => {
                            self.game_extra_info = ::std::option::Option::Some(is.read_string()?);
                        },
                        74 => {
                            self.account_name = ::std::option::Option::Some(is.read_string()?);
                        },
                        81 => {
                            self.lobby_steam_id = ::std::option::Option::Some(is.read_fixed64()?);
                        },
                        90 => {
                            self.rich_presence_kv = ::std::option::Option::Some(is.read_string()?);
                        },
                        97 => {
                            self.broadcast_session_id = ::std::option::Option::Some(is.read_fixed64()?);
                        },
                        104 => {
                            self.watching_broadcast_accountid = ::std::option::Option::Some(is.read_uint32()?);
                        },
                        112 => {
                            self.watching_broadcast_appid = ::std::option::Option::Some(is.read_uint32()?);
                        },
                        120 => {
                            self.watching_broadcast_viewers = ::std::option::Option::Some(is.read_uint32()?);
                        },
                        130 => {
                            self.watching_broadcast_title = ::std::option::Option::Some(is.read_string()?);
                        },
                        136 => {
                            self.last_logoff_time = ::std::option::Option::Some(is.read_uint32()?);
                        },
                        144 => {
                            self.last_seen_online = ::std::option::Option::Some(is.read_uint32()?);
                        },
                        152 => {
                            self.game_os_type = ::std::option::Option::Some(is.read_int32()?);
                        },
                        160 => {
                            self.game_device_type = ::std::option::Option::Some(is.read_int32()?);
                        },
                        170 => {
                            self.game_device_name = ::std::option::Option::Some(is.read_string()?);
                        },
                        176 => {
                            self.game_is_private = ::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.persona_state {
                    my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
                }
                if let Some(v) = self.persona_state_flags {
                    my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
                }
                if let Some(v) = self.time_created {
                    my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
                }
                if let Some(v) = self.game_id {
                    my_size += 1 + 8;
                }
                if let Some(v) = self.game_server_steam_id {
                    my_size += 1 + 8;
                }
                if let Some(v) = self.game_server_ip_address {
                    my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
                }
                if let Some(v) = self.game_server_port {
                    my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
                }
                if let Some(v) = self.game_extra_info.as_ref() {
                    my_size += ::steam_vent_proto_common::protobuf::rt::string_size(8, &v);
                }
                if let Some(v) = self.account_name.as_ref() {
                    my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &v);
                }
                if let Some(v) = self.lobby_steam_id {
                    my_size += 1 + 8;
                }
                if let Some(v) = self.rich_presence_kv.as_ref() {
                    my_size += ::steam_vent_proto_common::protobuf::rt::string_size(11, &v);
                }
                if let Some(v) = self.broadcast_session_id {
                    my_size += 1 + 8;
                }
                if let Some(v) = self.watching_broadcast_accountid {
                    my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(13, v);
                }
                if let Some(v) = self.watching_broadcast_appid {
                    my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(14, v);
                }
                if let Some(v) = self.watching_broadcast_viewers {
                    my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(15, v);
                }
                if let Some(v) = self.watching_broadcast_title.as_ref() {
                    my_size += ::steam_vent_proto_common::protobuf::rt::string_size(16, &v);
                }
                if let Some(v) = self.last_logoff_time {
                    my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(17, v);
                }
                if let Some(v) = self.last_seen_online {
                    my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(18, v);
                }
                if let Some(v) = self.game_os_type {
                    my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(19, v);
                }
                if let Some(v) = self.game_device_type {
                    my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(20, v);
                }
                if let Some(v) = self.game_device_name.as_ref() {
                    my_size += ::steam_vent_proto_common::protobuf::rt::string_size(21, &v);
                }
                if let Some(v) = self.game_is_private {
                    my_size += 2 + 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.persona_state {
                    os.write_int32(1, v)?;
                }
                if let Some(v) = self.persona_state_flags {
                    os.write_uint32(2, v)?;
                }
                if let Some(v) = self.time_created {
                    os.write_uint32(3, v)?;
                }
                if let Some(v) = self.game_id {
                    os.write_fixed64(4, v)?;
                }
                if let Some(v) = self.game_server_steam_id {
                    os.write_fixed64(5, v)?;
                }
                if let Some(v) = self.game_server_ip_address {
                    os.write_uint32(6, v)?;
                }
                if let Some(v) = self.game_server_port {
                    os.write_uint32(7, v)?;
                }
                if let Some(v) = self.game_extra_info.as_ref() {
                    os.write_string(8, v)?;
                }
                if let Some(v) = self.account_name.as_ref() {
                    os.write_string(9, v)?;
                }
                if let Some(v) = self.lobby_steam_id {
                    os.write_fixed64(10, v)?;
                }
                if let Some(v) = self.rich_presence_kv.as_ref() {
                    os.write_string(11, v)?;
                }
                if let Some(v) = self.broadcast_session_id {
                    os.write_fixed64(12, v)?;
                }
                if let Some(v) = self.watching_broadcast_accountid {
                    os.write_uint32(13, v)?;
                }
                if let Some(v) = self.watching_broadcast_appid {
                    os.write_uint32(14, v)?;
                }
                if let Some(v) = self.watching_broadcast_viewers {
                    os.write_uint32(15, v)?;
                }
                if let Some(v) = self.watching_broadcast_title.as_ref() {
                    os.write_string(16, v)?;
                }
                if let Some(v) = self.last_logoff_time {
                    os.write_uint32(17, v)?;
                }
                if let Some(v) = self.last_seen_online {
                    os.write_uint32(18, v)?;
                }
                if let Some(v) = self.game_os_type {
                    os.write_int32(19, v)?;
                }
                if let Some(v) = self.game_device_type {
                    os.write_int32(20, v)?;
                }
                if let Some(v) = self.game_device_name.as_ref() {
                    os.write_string(21, v)?;
                }
                if let Some(v) = self.game_is_private {
                    os.write_bool(22, 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() -> AccountPrivateData {
                AccountPrivateData::new()
            }

            fn clear(&mut self) {
                self.persona_state = ::std::option::Option::None;
                self.persona_state_flags = ::std::option::Option::None;
                self.time_created = ::std::option::Option::None;
                self.game_id = ::std::option::Option::None;
                self.game_server_steam_id = ::std::option::Option::None;
                self.game_server_ip_address = ::std::option::Option::None;
                self.game_server_port = ::std::option::Option::None;
                self.game_extra_info = ::std::option::Option::None;
                self.account_name = ::std::option::Option::None;
                self.lobby_steam_id = ::std::option::Option::None;
                self.rich_presence_kv = ::std::option::Option::None;
                self.broadcast_session_id = ::std::option::Option::None;
                self.watching_broadcast_accountid = ::std::option::Option::None;
                self.watching_broadcast_appid = ::std::option::Option::None;
                self.watching_broadcast_viewers = ::std::option::Option::None;
                self.watching_broadcast_title = ::std::option::Option::None;
                self.last_logoff_time = ::std::option::Option::None;
                self.last_seen_online = ::std::option::Option::None;
                self.game_os_type = ::std::option::Option::None;
                self.game_device_type = ::std::option::Option::None;
                self.game_device_name = ::std::option::Option::None;
                self.game_is_private = ::std::option::Option::None;
                self.special_fields.clear();
            }

            fn default_instance() -> &'static AccountPrivateData {
                static instance: AccountPrivateData = AccountPrivateData {
                    persona_state: ::std::option::Option::None,
                    persona_state_flags: ::std::option::Option::None,
                    time_created: ::std::option::Option::None,
                    game_id: ::std::option::Option::None,
                    game_server_steam_id: ::std::option::Option::None,
                    game_server_ip_address: ::std::option::Option::None,
                    game_server_port: ::std::option::Option::None,
                    game_extra_info: ::std::option::Option::None,
                    account_name: ::std::option::Option::None,
                    lobby_steam_id: ::std::option::Option::None,
                    rich_presence_kv: ::std::option::Option::None,
                    broadcast_session_id: ::std::option::Option::None,
                    watching_broadcast_accountid: ::std::option::Option::None,
                    watching_broadcast_appid: ::std::option::Option::None,
                    watching_broadcast_viewers: ::std::option::Option::None,
                    watching_broadcast_title: ::std::option::Option::None,
                    last_logoff_time: ::std::option::Option::None,
                    last_seen_online: ::std::option::Option::None,
                    game_os_type: ::std::option::Option::None,
                    game_device_type: ::std::option::Option::None,
                    game_device_name: ::std::option::Option::None,
                    game_is_private: ::std::option::Option::None,
                    special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }
    }
}

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

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

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

impl CPlayer_IncomingInviteMutualFriendList {
    pub fn new() -> CPlayer_IncomingInviteMutualFriendList {
        ::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 CPlayer_IncomingInviteMutualFriendList {
    const NAME: &'static str = "CPlayer_IncomingInviteMutualFriendList";

    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()?);
                },
                18 => {
                    is.read_repeated_packed_uint32_into(&mut self.mutual_friend_account_ids)?;
                },
                16 => {
                    self.mutual_friend_account_ids.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.steamid {
            my_size += 1 + 8;
        }
        for value in &self.mutual_friend_account_ids {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, *value);
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.steamid {
            os.write_fixed64(1, v)?;
        }
        for v in &self.mutual_friend_account_ids {
            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() -> CPlayer_IncomingInviteMutualFriendList {
        CPlayer_IncomingInviteMutualFriendList::new()
    }

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

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetMutualFriendsForIncomingInvites_Response {
    const NAME: &'static str = "CPlayer_GetMutualFriendsForIncomingInvites_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.incoming_invite_mutual_friends_lists.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.incoming_invite_mutual_friends_lists {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

// @@protoc_insertion_point(message:CPlayer_GetOwnedGames_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetOwnedGames_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Request.include_appinfo)
    pub include_appinfo: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Request.include_played_free_games)
    pub include_played_free_games: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Request.appids_filter)
    pub appids_filter: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Request.include_free_sub)
    pub include_free_sub: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Request.skip_unvetted_apps)
    pub skip_unvetted_apps: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Request.language)
    pub language: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Request.include_extended_appinfo)
    pub include_extended_appinfo: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetOwnedGames_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint64 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 bool include_appinfo = 2;

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

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

    pub fn has_include_appinfo(&self) -> bool {
        self.include_appinfo.is_some()
    }

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

    // optional bool include_played_free_games = 3;

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

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

    pub fn has_include_played_free_games(&self) -> bool {
        self.include_played_free_games.is_some()
    }

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

    // optional bool include_free_sub = 5;

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

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

    pub fn has_include_free_sub(&self) -> bool {
        self.include_free_sub.is_some()
    }

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

    // optional bool skip_unvetted_apps = 6;

    pub fn skip_unvetted_apps(&self) -> bool {
        self.skip_unvetted_apps.unwrap_or(true)
    }

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

    pub fn has_skip_unvetted_apps(&self) -> bool {
        self.skip_unvetted_apps.is_some()
    }

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

    // 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())
    }

    // optional bool include_extended_appinfo = 8;

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

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

    pub fn has_include_extended_appinfo(&self) -> bool {
        self.include_extended_appinfo.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetOwnedGames_Request {
    const NAME: &'static str = "CPlayer_GetOwnedGames_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.steamid = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.include_appinfo = ::std::option::Option::Some(is.read_bool()?);
                },
                24 => {
                    self.include_played_free_games = ::std::option::Option::Some(is.read_bool()?);
                },
                34 => {
                    is.read_repeated_packed_uint32_into(&mut self.appids_filter)?;
                },
                32 => {
                    self.appids_filter.push(is.read_uint32()?);
                },
                40 => {
                    self.include_free_sub = ::std::option::Option::Some(is.read_bool()?);
                },
                48 => {
                    self.skip_unvetted_apps = ::std::option::Option::Some(is.read_bool()?);
                },
                58 => {
                    self.language = ::std::option::Option::Some(is.read_string()?);
                },
                64 => {
                    self.include_extended_appinfo = ::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 += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.include_appinfo {
            my_size += 1 + 1;
        }
        if let Some(v) = self.include_played_free_games {
            my_size += 1 + 1;
        }
        for value in &self.appids_filter {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, *value);
        };
        if let Some(v) = self.include_free_sub {
            my_size += 1 + 1;
        }
        if let Some(v) = self.skip_unvetted_apps {
            my_size += 1 + 1;
        }
        if let Some(v) = self.language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
        }
        if let Some(v) = self.include_extended_appinfo {
            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_uint64(1, v)?;
        }
        if let Some(v) = self.include_appinfo {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.include_played_free_games {
            os.write_bool(3, v)?;
        }
        for v in &self.appids_filter {
            os.write_uint32(4, *v)?;
        };
        if let Some(v) = self.include_free_sub {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.skip_unvetted_apps {
            os.write_bool(6, v)?;
        }
        if let Some(v) = self.language.as_ref() {
            os.write_string(7, v)?;
        }
        if let Some(v) = self.include_extended_appinfo {
            os.write_bool(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() -> CPlayer_GetOwnedGames_Request {
        CPlayer_GetOwnedGames_Request::new()
    }

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.include_appinfo = ::std::option::Option::None;
        self.include_played_free_games = ::std::option::Option::None;
        self.appids_filter.clear();
        self.include_free_sub = ::std::option::Option::None;
        self.skip_unvetted_apps = ::std::option::Option::None;
        self.language = ::std::option::Option::None;
        self.include_extended_appinfo = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetOwnedGames_Request {
        static instance: CPlayer_GetOwnedGames_Request = CPlayer_GetOwnedGames_Request {
            steamid: ::std::option::Option::None,
            include_appinfo: ::std::option::Option::None,
            include_played_free_games: ::std::option::Option::None,
            appids_filter: ::std::vec::Vec::new(),
            include_free_sub: ::std::option::Option::None,
            skip_unvetted_apps: ::std::option::Option::None,
            language: ::std::option::Option::None,
            include_extended_appinfo: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional uint32 game_count = 1;

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

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

    pub fn has_game_count(&self) -> bool {
        self.game_count.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetOwnedGames_Response {
    const NAME: &'static str = "CPlayer_GetOwnedGames_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.game_count = ::std::option::Option::Some(is.read_uint32()?);
                },
                18 => {
                    self.games.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.game_count {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        for value in &self.games {
            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.game_count {
            os.write_uint32(1, v)?;
        }
        for v in &self.games {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

/// Nested message and enums of message `CPlayer_GetOwnedGames_Response`
pub mod cplayer_get_owned_games_response {
    // @@protoc_insertion_point(message:CPlayer_GetOwnedGames_Response.Game)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Game {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.appid)
        pub appid: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.name)
        pub name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.playtime_2weeks)
        pub playtime_2weeks: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.playtime_forever)
        pub playtime_forever: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.img_icon_url)
        pub img_icon_url: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.has_community_visible_stats)
        pub has_community_visible_stats: ::std::option::Option<bool>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.playtime_windows_forever)
        pub playtime_windows_forever: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.playtime_mac_forever)
        pub playtime_mac_forever: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.playtime_linux_forever)
        pub playtime_linux_forever: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.playtime_deck_forever)
        pub playtime_deck_forever: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.rtime_last_played)
        pub rtime_last_played: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.capsule_filename)
        pub capsule_filename: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.sort_as)
        pub sort_as: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.has_workshop)
        pub has_workshop: ::std::option::Option<bool>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.has_market)
        pub has_market: ::std::option::Option<bool>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.has_dlc)
        pub has_dlc: ::std::option::Option<bool>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.has_leaderboards)
        pub has_leaderboards: ::std::option::Option<bool>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.content_descriptorids)
        pub content_descriptorids: ::std::vec::Vec<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetOwnedGames_Response.Game.playtime_disconnected)
        pub playtime_disconnected: ::std::option::Option<i32>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetOwnedGames_Response.Game.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional int32 appid = 1;

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

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

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

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

        // optional string name = 2;

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

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

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

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

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

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

        // optional int32 playtime_2weeks = 3;

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

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

        pub fn has_playtime_2weeks(&self) -> bool {
            self.playtime_2weeks.is_some()
        }

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

        // optional int32 playtime_forever = 4;

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

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

        pub fn has_playtime_forever(&self) -> bool {
            self.playtime_forever.is_some()
        }

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

        // optional string img_icon_url = 5;

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

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

        pub fn has_img_icon_url(&self) -> bool {
            self.img_icon_url.is_some()
        }

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

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

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

        // optional bool has_community_visible_stats = 7;

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

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

        pub fn has_has_community_visible_stats(&self) -> bool {
            self.has_community_visible_stats.is_some()
        }

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

        // optional int32 playtime_windows_forever = 8;

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

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

        pub fn has_playtime_windows_forever(&self) -> bool {
            self.playtime_windows_forever.is_some()
        }

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

        // optional int32 playtime_mac_forever = 9;

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

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

        pub fn has_playtime_mac_forever(&self) -> bool {
            self.playtime_mac_forever.is_some()
        }

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

        // optional int32 playtime_linux_forever = 10;

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

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

        pub fn has_playtime_linux_forever(&self) -> bool {
            self.playtime_linux_forever.is_some()
        }

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

        // optional int32 playtime_deck_forever = 20;

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

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

        pub fn has_playtime_deck_forever(&self) -> bool {
            self.playtime_deck_forever.is_some()
        }

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

        // optional uint32 rtime_last_played = 11;

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

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

        pub fn has_rtime_last_played(&self) -> bool {
            self.rtime_last_played.is_some()
        }

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

        // optional string capsule_filename = 12;

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

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

        pub fn has_capsule_filename(&self) -> bool {
            self.capsule_filename.is_some()
        }

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

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

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

        // optional string sort_as = 13;

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

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

        pub fn has_sort_as(&self) -> bool {
            self.sort_as.is_some()
        }

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

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

        // optional bool has_workshop = 14;

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

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

        pub fn has_has_workshop(&self) -> bool {
            self.has_workshop.is_some()
        }

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

        // optional bool has_market = 15;

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

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

        pub fn has_has_market(&self) -> bool {
            self.has_market.is_some()
        }

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

        // optional bool has_dlc = 16;

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

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

        pub fn has_has_dlc(&self) -> bool {
            self.has_dlc.is_some()
        }

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

        // optional bool has_leaderboards = 17;

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

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

        pub fn has_has_leaderboards(&self) -> bool {
            self.has_leaderboards.is_some()
        }

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

        // optional int32 playtime_disconnected = 19;

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

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

        pub fn has_playtime_disconnected(&self) -> bool {
            self.playtime_disconnected.is_some()
        }

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

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

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

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.appid = ::std::option::Option::Some(is.read_int32()?);
                    },
                    18 => {
                        self.name = ::std::option::Option::Some(is.read_string()?);
                    },
                    24 => {
                        self.playtime_2weeks = ::std::option::Option::Some(is.read_int32()?);
                    },
                    32 => {
                        self.playtime_forever = ::std::option::Option::Some(is.read_int32()?);
                    },
                    42 => {
                        self.img_icon_url = ::std::option::Option::Some(is.read_string()?);
                    },
                    56 => {
                        self.has_community_visible_stats = ::std::option::Option::Some(is.read_bool()?);
                    },
                    64 => {
                        self.playtime_windows_forever = ::std::option::Option::Some(is.read_int32()?);
                    },
                    72 => {
                        self.playtime_mac_forever = ::std::option::Option::Some(is.read_int32()?);
                    },
                    80 => {
                        self.playtime_linux_forever = ::std::option::Option::Some(is.read_int32()?);
                    },
                    160 => {
                        self.playtime_deck_forever = ::std::option::Option::Some(is.read_int32()?);
                    },
                    88 => {
                        self.rtime_last_played = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    98 => {
                        self.capsule_filename = ::std::option::Option::Some(is.read_string()?);
                    },
                    106 => {
                        self.sort_as = ::std::option::Option::Some(is.read_string()?);
                    },
                    112 => {
                        self.has_workshop = ::std::option::Option::Some(is.read_bool()?);
                    },
                    120 => {
                        self.has_market = ::std::option::Option::Some(is.read_bool()?);
                    },
                    128 => {
                        self.has_dlc = ::std::option::Option::Some(is.read_bool()?);
                    },
                    136 => {
                        self.has_leaderboards = ::std::option::Option::Some(is.read_bool()?);
                    },
                    146 => {
                        is.read_repeated_packed_uint32_into(&mut self.content_descriptorids)?;
                    },
                    144 => {
                        self.content_descriptorids.push(is.read_uint32()?);
                    },
                    152 => {
                        self.playtime_disconnected = ::std::option::Option::Some(is.read_int32()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if let Some(v) = self.appid {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
            }
            if let Some(v) = self.name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
            }
            if let Some(v) = self.playtime_2weeks {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v);
            }
            if let Some(v) = self.playtime_forever {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v);
            }
            if let Some(v) = self.img_icon_url.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &v);
            }
            if let Some(v) = self.has_community_visible_stats {
                my_size += 1 + 1;
            }
            if let Some(v) = self.playtime_windows_forever {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(8, v);
            }
            if let Some(v) = self.playtime_mac_forever {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(9, v);
            }
            if let Some(v) = self.playtime_linux_forever {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(10, v);
            }
            if let Some(v) = self.playtime_deck_forever {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(20, v);
            }
            if let Some(v) = self.rtime_last_played {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(11, v);
            }
            if let Some(v) = self.capsule_filename.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(12, &v);
            }
            if let Some(v) = self.sort_as.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(13, &v);
            }
            if let Some(v) = self.has_workshop {
                my_size += 1 + 1;
            }
            if let Some(v) = self.has_market {
                my_size += 1 + 1;
            }
            if let Some(v) = self.has_dlc {
                my_size += 2 + 1;
            }
            if let Some(v) = self.has_leaderboards {
                my_size += 2 + 1;
            }
            for value in &self.content_descriptorids {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(18, *value);
            };
            if let Some(v) = self.playtime_disconnected {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(19, v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.appid {
                os.write_int32(1, v)?;
            }
            if let Some(v) = self.name.as_ref() {
                os.write_string(2, v)?;
            }
            if let Some(v) = self.playtime_2weeks {
                os.write_int32(3, v)?;
            }
            if let Some(v) = self.playtime_forever {
                os.write_int32(4, v)?;
            }
            if let Some(v) = self.img_icon_url.as_ref() {
                os.write_string(5, v)?;
            }
            if let Some(v) = self.has_community_visible_stats {
                os.write_bool(7, v)?;
            }
            if let Some(v) = self.playtime_windows_forever {
                os.write_int32(8, v)?;
            }
            if let Some(v) = self.playtime_mac_forever {
                os.write_int32(9, v)?;
            }
            if let Some(v) = self.playtime_linux_forever {
                os.write_int32(10, v)?;
            }
            if let Some(v) = self.playtime_deck_forever {
                os.write_int32(20, v)?;
            }
            if let Some(v) = self.rtime_last_played {
                os.write_uint32(11, v)?;
            }
            if let Some(v) = self.capsule_filename.as_ref() {
                os.write_string(12, v)?;
            }
            if let Some(v) = self.sort_as.as_ref() {
                os.write_string(13, v)?;
            }
            if let Some(v) = self.has_workshop {
                os.write_bool(14, v)?;
            }
            if let Some(v) = self.has_market {
                os.write_bool(15, v)?;
            }
            if let Some(v) = self.has_dlc {
                os.write_bool(16, v)?;
            }
            if let Some(v) = self.has_leaderboards {
                os.write_bool(17, v)?;
            }
            for v in &self.content_descriptorids {
                os.write_uint32(18, *v)?;
            };
            if let Some(v) = self.playtime_disconnected {
                os.write_int32(19, 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() -> Game {
            Game::new()
        }

        fn clear(&mut self) {
            self.appid = ::std::option::Option::None;
            self.name = ::std::option::Option::None;
            self.playtime_2weeks = ::std::option::Option::None;
            self.playtime_forever = ::std::option::Option::None;
            self.img_icon_url = ::std::option::Option::None;
            self.has_community_visible_stats = ::std::option::Option::None;
            self.playtime_windows_forever = ::std::option::Option::None;
            self.playtime_mac_forever = ::std::option::Option::None;
            self.playtime_linux_forever = ::std::option::Option::None;
            self.playtime_deck_forever = ::std::option::Option::None;
            self.rtime_last_played = ::std::option::Option::None;
            self.capsule_filename = ::std::option::Option::None;
            self.sort_as = ::std::option::Option::None;
            self.has_workshop = ::std::option::Option::None;
            self.has_market = ::std::option::Option::None;
            self.has_dlc = ::std::option::Option::None;
            self.has_leaderboards = ::std::option::Option::None;
            self.content_descriptorids.clear();
            self.playtime_disconnected = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Game {
            static instance: Game = Game {
                appid: ::std::option::Option::None,
                name: ::std::option::Option::None,
                playtime_2weeks: ::std::option::Option::None,
                playtime_forever: ::std::option::Option::None,
                img_icon_url: ::std::option::Option::None,
                has_community_visible_stats: ::std::option::Option::None,
                playtime_windows_forever: ::std::option::Option::None,
                playtime_mac_forever: ::std::option::Option::None,
                playtime_linux_forever: ::std::option::Option::None,
                playtime_deck_forever: ::std::option::Option::None,
                rtime_last_played: ::std::option::Option::None,
                capsule_filename: ::std::option::Option::None,
                sort_as: ::std::option::Option::None,
                has_workshop: ::std::option::Option::None,
                has_market: ::std::option::Option::None,
                has_dlc: ::std::option::Option::None,
                has_leaderboards: ::std::option::Option::None,
                content_descriptorids: ::std::vec::Vec::new(),
                playtime_disconnected: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

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

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

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

    // optional uint32 max_age_seconds = 1;

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

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

    pub fn has_max_age_seconds(&self) -> bool {
        self.max_age_seconds.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetPlayNext_Request {
    const NAME: &'static str = "CPlayer_GetPlayNext_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.max_age_seconds = ::std::option::Option::Some(is.read_uint32()?);
                },
                18 => {
                    is.read_repeated_packed_uint32_into(&mut self.ignore_appids)?;
                },
                16 => {
                    self.ignore_appids.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.max_age_seconds {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        for value in &self.ignore_appids {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, *value);
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.max_age_seconds {
            os.write_uint32(1, v)?;
        }
        for v in &self.ignore_appids {
            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() -> CPlayer_GetPlayNext_Request {
        CPlayer_GetPlayNext_Request::new()
    }

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

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

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

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

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

    // optional uint32 last_update_time = 1;

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

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

    pub fn has_last_update_time(&self) -> bool {
        self.last_update_time.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetPlayNext_Response {
    const NAME: &'static str = "CPlayer_GetPlayNext_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.last_update_time = ::std::option::Option::Some(is.read_uint32()?);
                },
                18 => {
                    is.read_repeated_packed_uint32_into(&mut self.appids)?;
                },
                16 => {
                    self.appids.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.last_update_time {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        for value in &self.appids {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, *value);
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.last_update_time {
            os.write_uint32(1, v)?;
        }
        for v in &self.appids {
            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() -> CPlayer_GetPlayNext_Response {
        CPlayer_GetPlayNext_Response::new()
    }

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

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

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

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

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

    // optional uint32 appid = 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// @@protoc_insertion_point(message:CPlayer_GetFriendsGameplayInfo_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetFriendsGameplayInfo_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetFriendsGameplayInfo_Response.your_info)
    pub your_info: ::steam_vent_proto_common::protobuf::MessageField<cplayer_get_friends_gameplay_info_response::OwnGameplayInfo>,
    // @@protoc_insertion_point(field:CPlayer_GetFriendsGameplayInfo_Response.in_game)
    pub in_game: ::std::vec::Vec<cplayer_get_friends_gameplay_info_response::FriendsGameplayInfo>,
    // @@protoc_insertion_point(field:CPlayer_GetFriendsGameplayInfo_Response.played_recently)
    pub played_recently: ::std::vec::Vec<cplayer_get_friends_gameplay_info_response::FriendsGameplayInfo>,
    // @@protoc_insertion_point(field:CPlayer_GetFriendsGameplayInfo_Response.played_ever)
    pub played_ever: ::std::vec::Vec<cplayer_get_friends_gameplay_info_response::FriendsGameplayInfo>,
    // @@protoc_insertion_point(field:CPlayer_GetFriendsGameplayInfo_Response.owns)
    pub owns: ::std::vec::Vec<cplayer_get_friends_gameplay_info_response::FriendsGameplayInfo>,
    // @@protoc_insertion_point(field:CPlayer_GetFriendsGameplayInfo_Response.in_wishlist)
    pub in_wishlist: ::std::vec::Vec<cplayer_get_friends_gameplay_info_response::FriendsGameplayInfo>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetFriendsGameplayInfo_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.your_info)?;
                },
                18 => {
                    self.in_game.push(is.read_message()?);
                },
                26 => {
                    self.played_recently.push(is.read_message()?);
                },
                34 => {
                    self.played_ever.push(is.read_message()?);
                },
                42 => {
                    self.owns.push(is.read_message()?);
                },
                50 => {
                    self.in_wishlist.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.your_info.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.in_game {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.played_recently {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.played_ever {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.owns {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.in_wishlist {
            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.your_info.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        for v in &self.in_game {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        for v in &self.played_recently {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        for v in &self.played_ever {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        for v in &self.owns {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        };
        for v in &self.in_wishlist {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.your_info.clear();
        self.in_game.clear();
        self.played_recently.clear();
        self.played_ever.clear();
        self.owns.clear();
        self.in_wishlist.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetFriendsGameplayInfo_Response {
        static instance: CPlayer_GetFriendsGameplayInfo_Response = CPlayer_GetFriendsGameplayInfo_Response {
            your_info: ::steam_vent_proto_common::protobuf::MessageField::none(),
            in_game: ::std::vec::Vec::new(),
            played_recently: ::std::vec::Vec::new(),
            played_ever: ::std::vec::Vec::new(),
            owns: ::std::vec::Vec::new(),
            in_wishlist: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CPlayer_GetFriendsGameplayInfo_Response`
pub mod cplayer_get_friends_gameplay_info_response {
    // @@protoc_insertion_point(message:CPlayer_GetFriendsGameplayInfo_Response.FriendsGameplayInfo)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct FriendsGameplayInfo {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetFriendsGameplayInfo_Response.FriendsGameplayInfo.steamid)
        pub steamid: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CPlayer_GetFriendsGameplayInfo_Response.FriendsGameplayInfo.minutes_played)
        pub minutes_played: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetFriendsGameplayInfo_Response.FriendsGameplayInfo.minutes_played_forever)
        pub minutes_played_forever: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetFriendsGameplayInfo_Response.FriendsGameplayInfo.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

    impl FriendsGameplayInfo {
        pub fn new() -> FriendsGameplayInfo {
            ::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 minutes_played = 2;

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

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

        pub fn has_minutes_played(&self) -> bool {
            self.minutes_played.is_some()
        }

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

        // optional uint32 minutes_played_forever = 3;

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

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

        pub fn has_minutes_played_forever(&self) -> bool {
            self.minutes_played_forever.is_some()
        }

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

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

        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.minutes_played = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    24 => {
                        self.minutes_played_forever = ::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 {
                my_size += 1 + 8;
            }
            if let Some(v) = self.minutes_played {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
            }
            if let Some(v) = self.minutes_played_forever {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.steamid {
                os.write_fixed64(1, v)?;
            }
            if let Some(v) = self.minutes_played {
                os.write_uint32(2, v)?;
            }
            if let Some(v) = self.minutes_played_forever {
                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() -> FriendsGameplayInfo {
            FriendsGameplayInfo::new()
        }

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

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

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

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

    impl OwnGameplayInfo {
        pub fn new() -> OwnGameplayInfo {
            ::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 minutes_played = 2;

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

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

        pub fn has_minutes_played(&self) -> bool {
            self.minutes_played.is_some()
        }

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

        // optional uint32 minutes_played_forever = 3;

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

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

        pub fn has_minutes_played_forever(&self) -> bool {
            self.minutes_played_forever.is_some()
        }

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

        // optional bool in_wishlist = 4;

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

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

        pub fn has_in_wishlist(&self) -> bool {
            self.in_wishlist.is_some()
        }

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

        // optional bool owned = 5;

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

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

        pub fn has_owned(&self) -> bool {
            self.owned.is_some()
        }

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

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

        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.minutes_played = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    24 => {
                        self.minutes_played_forever = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    32 => {
                        self.in_wishlist = ::std::option::Option::Some(is.read_bool()?);
                    },
                    40 => {
                        self.owned = ::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.minutes_played {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
            }
            if let Some(v) = self.minutes_played_forever {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
            }
            if let Some(v) = self.in_wishlist {
                my_size += 1 + 1;
            }
            if let Some(v) = self.owned {
                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.minutes_played {
                os.write_uint32(2, v)?;
            }
            if let Some(v) = self.minutes_played_forever {
                os.write_uint32(3, v)?;
            }
            if let Some(v) = self.in_wishlist {
                os.write_bool(4, v)?;
            }
            if let Some(v) = self.owned {
                os.write_bool(5, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

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

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

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

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

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

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

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

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

    // optional uint32 appid = 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional uint32 player_level = 1;

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

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

    pub fn has_player_level(&self) -> bool {
        self.player_level.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetGameBadgeLevels_Response {
    const NAME: &'static str = "CPlayer_GetGameBadgeLevels_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.player_level = ::std::option::Option::Some(is.read_uint32()?);
                },
                18 => {
                    self.badges.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.player_level {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        for value in &self.badges {
            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.player_level {
            os.write_uint32(1, v)?;
        }
        for v in &self.badges {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

/// Nested message and enums of message `CPlayer_GetGameBadgeLevels_Response`
pub mod cplayer_get_game_badge_levels_response {
    // @@protoc_insertion_point(message:CPlayer_GetGameBadgeLevels_Response.Badge)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Badge {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetGameBadgeLevels_Response.Badge.level)
        pub level: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetGameBadgeLevels_Response.Badge.series)
        pub series: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetGameBadgeLevels_Response.Badge.border_color)
        pub border_color: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetGameBadgeLevels_Response.Badge.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional int32 level = 1;

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

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

        pub fn has_level(&self) -> bool {
            self.level.is_some()
        }

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

        // optional int32 series = 2;

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

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

        pub fn has_series(&self) -> bool {
            self.series.is_some()
        }

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

        // optional uint32 border_color = 3;

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

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

        pub fn has_border_color(&self) -> bool {
            self.border_color.is_some()
        }

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

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

        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.level = ::std::option::Option::Some(is.read_int32()?);
                    },
                    16 => {
                        self.series = ::std::option::Option::Some(is.read_int32()?);
                    },
                    24 => {
                        self.border_color = ::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.level {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
            }
            if let Some(v) = self.series {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
            }
            if let Some(v) = self.border_color {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.level {
                os.write_int32(1, v)?;
            }
            if let Some(v) = self.series {
                os.write_int32(2, v)?;
            }
            if let Some(v) = self.border_color {
                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() -> Badge {
            Badge::new()
        }

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

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

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

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

impl CPlayer_GetProfileBackground_Request {
    pub fn new() -> CPlayer_GetProfileBackground_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 string language = 2;

    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 CPlayer_GetProfileBackground_Request {
    const NAME: &'static str = "CPlayer_GetProfileBackground_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()?);
                },
                18 => {
                    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 {
            my_size += 1 + 8;
        }
        if let Some(v) = self.language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

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

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

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

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

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

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

// @@protoc_insertion_point(message:ProfileItem)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ProfileItem {
    // message fields
    // @@protoc_insertion_point(field:ProfileItem.communityitemid)
    pub communityitemid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:ProfileItem.image_small)
    pub image_small: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:ProfileItem.image_large)
    pub image_large: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:ProfileItem.name)
    pub name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:ProfileItem.item_title)
    pub item_title: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:ProfileItem.item_description)
    pub item_description: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:ProfileItem.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:ProfileItem.item_type)
    pub item_type: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:ProfileItem.item_class)
    pub item_class: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:ProfileItem.movie_webm)
    pub movie_webm: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:ProfileItem.movie_mp4)
    pub movie_mp4: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:ProfileItem.movie_webm_small)
    pub movie_webm_small: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:ProfileItem.movie_mp4_small)
    pub movie_mp4_small: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:ProfileItem.equipped_flags)
    pub equipped_flags: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:ProfileItem.profile_colors)
    pub profile_colors: ::std::vec::Vec<profile_item::ProfileColor>,
    // @@protoc_insertion_point(field:ProfileItem.tiled)
    pub tiled: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:ProfileItem.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint64 communityitemid = 1;

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

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

    pub fn has_communityitemid(&self) -> bool {
        self.communityitemid.is_some()
    }

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

    // optional string image_small = 2;

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

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

    pub fn has_image_small(&self) -> bool {
        self.image_small.is_some()
    }

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

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

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

    // optional string image_large = 3;

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

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

    pub fn has_image_large(&self) -> bool {
        self.image_large.is_some()
    }

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

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

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

    // optional string name = 4;

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

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

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

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

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

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

    // optional string item_title = 5;

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

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

    pub fn has_item_title(&self) -> bool {
        self.item_title.is_some()
    }

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

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

    // optional string item_description = 6;

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

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

    pub fn has_item_description(&self) -> bool {
        self.item_description.is_some()
    }

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

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

    // optional uint32 appid = 7;

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

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

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

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

    // optional uint32 item_type = 8;

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

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

    pub fn has_item_type(&self) -> bool {
        self.item_type.is_some()
    }

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

    // optional uint32 item_class = 9;

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

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

    pub fn has_item_class(&self) -> bool {
        self.item_class.is_some()
    }

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

    // optional string movie_webm = 10;

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

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

    pub fn has_movie_webm(&self) -> bool {
        self.movie_webm.is_some()
    }

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

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

    // optional string movie_mp4 = 11;

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

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

    pub fn has_movie_mp4(&self) -> bool {
        self.movie_mp4.is_some()
    }

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

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

    // optional string movie_webm_small = 13;

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

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

    pub fn has_movie_webm_small(&self) -> bool {
        self.movie_webm_small.is_some()
    }

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

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

    // optional string movie_mp4_small = 14;

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

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

    pub fn has_movie_mp4_small(&self) -> bool {
        self.movie_mp4_small.is_some()
    }

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

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

    // optional uint32 equipped_flags = 12;

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

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

    pub fn has_equipped_flags(&self) -> bool {
        self.equipped_flags.is_some()
    }

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

    // optional bool tiled = 16;

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

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

    pub fn has_tiled(&self) -> bool {
        self.tiled.is_some()
    }

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

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

    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.communityitemid = ::std::option::Option::Some(is.read_uint64()?);
                },
                18 => {
                    self.image_small = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    self.image_large = ::std::option::Option::Some(is.read_string()?);
                },
                34 => {
                    self.name = ::std::option::Option::Some(is.read_string()?);
                },
                42 => {
                    self.item_title = ::std::option::Option::Some(is.read_string()?);
                },
                50 => {
                    self.item_description = ::std::option::Option::Some(is.read_string()?);
                },
                56 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                64 => {
                    self.item_type = ::std::option::Option::Some(is.read_uint32()?);
                },
                72 => {
                    self.item_class = ::std::option::Option::Some(is.read_uint32()?);
                },
                82 => {
                    self.movie_webm = ::std::option::Option::Some(is.read_string()?);
                },
                90 => {
                    self.movie_mp4 = ::std::option::Option::Some(is.read_string()?);
                },
                106 => {
                    self.movie_webm_small = ::std::option::Option::Some(is.read_string()?);
                },
                114 => {
                    self.movie_mp4_small = ::std::option::Option::Some(is.read_string()?);
                },
                96 => {
                    self.equipped_flags = ::std::option::Option::Some(is.read_uint32()?);
                },
                122 => {
                    self.profile_colors.push(is.read_message()?);
                },
                128 => {
                    self.tiled = ::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.communityitemid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.image_small.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.image_large.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.item_title.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &v);
        }
        if let Some(v) = self.item_description.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.item_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, v);
        }
        if let Some(v) = self.item_class {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
        }
        if let Some(v) = self.movie_webm.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(10, &v);
        }
        if let Some(v) = self.movie_mp4.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(11, &v);
        }
        if let Some(v) = self.movie_webm_small.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(13, &v);
        }
        if let Some(v) = self.movie_mp4_small.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(14, &v);
        }
        if let Some(v) = self.equipped_flags {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(12, v);
        }
        for value in &self.profile_colors {
            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.tiled {
            my_size += 2 + 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.communityitemid {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.image_small.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.image_large.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.name.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.item_title.as_ref() {
            os.write_string(5, v)?;
        }
        if let Some(v) = self.item_description.as_ref() {
            os.write_string(6, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.item_type {
            os.write_uint32(8, v)?;
        }
        if let Some(v) = self.item_class {
            os.write_uint32(9, v)?;
        }
        if let Some(v) = self.movie_webm.as_ref() {
            os.write_string(10, v)?;
        }
        if let Some(v) = self.movie_mp4.as_ref() {
            os.write_string(11, v)?;
        }
        if let Some(v) = self.movie_webm_small.as_ref() {
            os.write_string(13, v)?;
        }
        if let Some(v) = self.movie_mp4_small.as_ref() {
            os.write_string(14, v)?;
        }
        if let Some(v) = self.equipped_flags {
            os.write_uint32(12, v)?;
        }
        for v in &self.profile_colors {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(15, v, os)?;
        };
        if let Some(v) = self.tiled {
            os.write_bool(16, 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() -> ProfileItem {
        ProfileItem::new()
    }

    fn clear(&mut self) {
        self.communityitemid = ::std::option::Option::None;
        self.image_small = ::std::option::Option::None;
        self.image_large = ::std::option::Option::None;
        self.name = ::std::option::Option::None;
        self.item_title = ::std::option::Option::None;
        self.item_description = ::std::option::Option::None;
        self.appid = ::std::option::Option::None;
        self.item_type = ::std::option::Option::None;
        self.item_class = ::std::option::Option::None;
        self.movie_webm = ::std::option::Option::None;
        self.movie_mp4 = ::std::option::Option::None;
        self.movie_webm_small = ::std::option::Option::None;
        self.movie_mp4_small = ::std::option::Option::None;
        self.equipped_flags = ::std::option::Option::None;
        self.profile_colors.clear();
        self.tiled = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ProfileItem {
        static instance: ProfileItem = ProfileItem {
            communityitemid: ::std::option::Option::None,
            image_small: ::std::option::Option::None,
            image_large: ::std::option::Option::None,
            name: ::std::option::Option::None,
            item_title: ::std::option::Option::None,
            item_description: ::std::option::Option::None,
            appid: ::std::option::Option::None,
            item_type: ::std::option::Option::None,
            item_class: ::std::option::Option::None,
            movie_webm: ::std::option::Option::None,
            movie_mp4: ::std::option::Option::None,
            movie_webm_small: ::std::option::Option::None,
            movie_mp4_small: ::std::option::Option::None,
            equipped_flags: ::std::option::Option::None,
            profile_colors: ::std::vec::Vec::new(),
            tiled: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `ProfileItem`
pub mod profile_item {
    // @@protoc_insertion_point(message:ProfileItem.ProfileColor)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct ProfileColor {
        // message fields
        // @@protoc_insertion_point(field:ProfileItem.ProfileColor.style_name)
        pub style_name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:ProfileItem.ProfileColor.color)
        pub color: ::std::option::Option<::std::string::String>,
        // special fields
        // @@protoc_insertion_point(special_field:ProfileItem.ProfileColor.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional string style_name = 1;

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

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

        pub fn has_style_name(&self) -> bool {
            self.style_name.is_some()
        }

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

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

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

        // optional string color = 2;

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

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

        pub fn has_color(&self) -> bool {
            self.color.is_some()
        }

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

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

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

        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.style_name = ::std::option::Option::Some(is.read_string()?);
                    },
                    18 => {
                        self.color = ::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.style_name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
            }
            if let Some(v) = self.color.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

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

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

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

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

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

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

// @@protoc_insertion_point(message:CPlayer_GetProfileBackground_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetProfileBackground_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetProfileBackground_Response.profile_background)
    pub profile_background: ::steam_vent_proto_common::protobuf::MessageField<ProfileItem>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetProfileBackground_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.profile_background)?;
                },
                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.profile_background.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

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

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

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

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

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

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

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

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

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

    // optional uint64 communityitemid = 1;

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

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

    pub fn has_communityitemid(&self) -> bool {
        self.communityitemid.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetProfileBackground_Request {
    const NAME: &'static str = "CPlayer_SetProfileBackground_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.communityitemid = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl CPlayer_GetMiniProfileBackground_Request {
    pub fn new() -> CPlayer_GetMiniProfileBackground_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 string language = 2;

    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 CPlayer_GetMiniProfileBackground_Request {
    const NAME: &'static str = "CPlayer_GetMiniProfileBackground_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()?);
                },
                18 => {
                    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 {
            my_size += 1 + 8;
        }
        if let Some(v) = self.language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

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

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

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

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

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

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

// @@protoc_insertion_point(message:CPlayer_GetMiniProfileBackground_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetMiniProfileBackground_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetMiniProfileBackground_Response.profile_background)
    pub profile_background: ::steam_vent_proto_common::protobuf::MessageField<ProfileItem>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetMiniProfileBackground_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.profile_background)?;
                },
                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.profile_background.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

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

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

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

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

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

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

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

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

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

    // optional uint64 communityitemid = 1;

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

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

    pub fn has_communityitemid(&self) -> bool {
        self.communityitemid.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetMiniProfileBackground_Request {
    const NAME: &'static str = "CPlayer_SetMiniProfileBackground_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.communityitemid = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl CPlayer_GetAvatarFrame_Request {
    pub fn new() -> CPlayer_GetAvatarFrame_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 string language = 2;

    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 CPlayer_GetAvatarFrame_Request {
    const NAME: &'static str = "CPlayer_GetAvatarFrame_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()?);
                },
                18 => {
                    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 {
            my_size += 1 + 8;
        }
        if let Some(v) = self.language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

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

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

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

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

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

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

// @@protoc_insertion_point(message:CPlayer_GetAvatarFrame_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetAvatarFrame_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetAvatarFrame_Response.avatar_frame)
    pub avatar_frame: ::steam_vent_proto_common::protobuf::MessageField<ProfileItem>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetAvatarFrame_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.avatar_frame)?;
                },
                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.avatar_frame.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

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

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

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

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

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

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

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

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

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

    // optional uint64 communityitemid = 1;

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

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

    pub fn has_communityitemid(&self) -> bool {
        self.communityitemid.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetAvatarFrame_Request {
    const NAME: &'static str = "CPlayer_SetAvatarFrame_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.communityitemid = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl CPlayer_GetAnimatedAvatar_Request {
    pub fn new() -> CPlayer_GetAnimatedAvatar_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 string language = 2;

    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 CPlayer_GetAnimatedAvatar_Request {
    const NAME: &'static str = "CPlayer_GetAnimatedAvatar_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()?);
                },
                18 => {
                    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 {
            my_size += 1 + 8;
        }
        if let Some(v) = self.language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

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

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

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

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

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

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

// @@protoc_insertion_point(message:CPlayer_GetAnimatedAvatar_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetAnimatedAvatar_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetAnimatedAvatar_Response.avatar)
    pub avatar: ::steam_vent_proto_common::protobuf::MessageField<ProfileItem>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetAnimatedAvatar_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.avatar)?;
                },
                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.avatar.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

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

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

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

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

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

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

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

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

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

    // optional uint64 communityitemid = 1;

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

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

    pub fn has_communityitemid(&self) -> bool {
        self.communityitemid.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetAnimatedAvatar_Request {
    const NAME: &'static str = "CPlayer_SetAnimatedAvatar_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.communityitemid = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl CPlayer_GetSteamDeckKeyboardSkin_Request {
    pub fn new() -> CPlayer_GetSteamDeckKeyboardSkin_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 string language = 2;

    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 CPlayer_GetSteamDeckKeyboardSkin_Request {
    const NAME: &'static str = "CPlayer_GetSteamDeckKeyboardSkin_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()?);
                },
                18 => {
                    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 {
            my_size += 1 + 8;
        }
        if let Some(v) = self.language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

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

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

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

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

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

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

// @@protoc_insertion_point(message:CPlayer_GetSteamDeckKeyboardSkin_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetSteamDeckKeyboardSkin_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetSteamDeckKeyboardSkin_Response.steam_deck_keyboard_skin)
    pub steam_deck_keyboard_skin: ::steam_vent_proto_common::protobuf::MessageField<ProfileItem>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetSteamDeckKeyboardSkin_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.steam_deck_keyboard_skin)?;
                },
                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.steam_deck_keyboard_skin.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

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

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

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

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

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

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

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

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

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

    // optional uint64 communityitemid = 1;

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

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

    pub fn has_communityitemid(&self) -> bool {
        self.communityitemid.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetSteamDeckKeyboardSkin_Request {
    const NAME: &'static str = "CPlayer_SetSteamDeckKeyboardSkin_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.communityitemid = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

// @@protoc_insertion_point(message:CPlayer_GetProfileItemsOwned_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetProfileItemsOwned_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetProfileItemsOwned_Request.language)
    pub language: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileItemsOwned_Request.filters)
    pub filters: ::std::vec::Vec<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::enums::ECommunityItemClass>>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetProfileItemsOwned_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string language = 1;

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.language = ::std::option::Option::Some(is.read_string()?);
                },
                16 => {
                    self.filters.push(is.read_enum_or_unknown()?);
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.filters)?
                },
                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.language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        for value in &self.filters {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, value.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.language.as_ref() {
            os.write_string(1, v)?;
        }
        for v in &self.filters {
            os.write_enum(2, ::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() -> CPlayer_GetProfileItemsOwned_Request {
        CPlayer_GetProfileItemsOwned_Request::new()
    }

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

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

// @@protoc_insertion_point(message:CPlayer_GetProfileItemsOwned_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetProfileItemsOwned_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetProfileItemsOwned_Response.profile_backgrounds)
    pub profile_backgrounds: ::std::vec::Vec<ProfileItem>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileItemsOwned_Response.mini_profile_backgrounds)
    pub mini_profile_backgrounds: ::std::vec::Vec<ProfileItem>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileItemsOwned_Response.avatar_frames)
    pub avatar_frames: ::std::vec::Vec<ProfileItem>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileItemsOwned_Response.animated_avatars)
    pub animated_avatars: ::std::vec::Vec<ProfileItem>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileItemsOwned_Response.profile_modifiers)
    pub profile_modifiers: ::std::vec::Vec<ProfileItem>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileItemsOwned_Response.steam_deck_keyboard_skins)
    pub steam_deck_keyboard_skins: ::std::vec::Vec<ProfileItem>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileItemsOwned_Response.steam_deck_startup_movies)
    pub steam_deck_startup_movies: ::std::vec::Vec<ProfileItem>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetProfileItemsOwned_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetProfileItemsOwned_Response {
    const NAME: &'static str = "CPlayer_GetProfileItemsOwned_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.profile_backgrounds.push(is.read_message()?);
                },
                18 => {
                    self.mini_profile_backgrounds.push(is.read_message()?);
                },
                26 => {
                    self.avatar_frames.push(is.read_message()?);
                },
                34 => {
                    self.animated_avatars.push(is.read_message()?);
                },
                42 => {
                    self.profile_modifiers.push(is.read_message()?);
                },
                50 => {
                    self.steam_deck_keyboard_skins.push(is.read_message()?);
                },
                58 => {
                    self.steam_deck_startup_movies.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.profile_backgrounds {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.mini_profile_backgrounds {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.avatar_frames {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.animated_avatars {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.profile_modifiers {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.steam_deck_keyboard_skins {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.steam_deck_startup_movies {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.profile_backgrounds {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        for v in &self.mini_profile_backgrounds {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        for v in &self.avatar_frames {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        for v in &self.animated_avatars {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        for v in &self.profile_modifiers {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        };
        for v in &self.steam_deck_keyboard_skins {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        };
        for v in &self.steam_deck_startup_movies {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(7, 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() -> CPlayer_GetProfileItemsOwned_Response {
        CPlayer_GetProfileItemsOwned_Response::new()
    }

    fn clear(&mut self) {
        self.profile_backgrounds.clear();
        self.mini_profile_backgrounds.clear();
        self.avatar_frames.clear();
        self.animated_avatars.clear();
        self.profile_modifiers.clear();
        self.steam_deck_keyboard_skins.clear();
        self.steam_deck_startup_movies.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetProfileItemsOwned_Response {
        static instance: CPlayer_GetProfileItemsOwned_Response = CPlayer_GetProfileItemsOwned_Response {
            profile_backgrounds: ::std::vec::Vec::new(),
            mini_profile_backgrounds: ::std::vec::Vec::new(),
            avatar_frames: ::std::vec::Vec::new(),
            animated_avatars: ::std::vec::Vec::new(),
            profile_modifiers: ::std::vec::Vec::new(),
            steam_deck_keyboard_skins: ::std::vec::Vec::new(),
            steam_deck_startup_movies: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

impl CPlayer_GetProfileItemsEquipped_Request {
    pub fn new() -> CPlayer_GetProfileItemsEquipped_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 string language = 2;

    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 CPlayer_GetProfileItemsEquipped_Request {
    const NAME: &'static str = "CPlayer_GetProfileItemsEquipped_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()?);
                },
                18 => {
                    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 {
            my_size += 1 + 8;
        }
        if let Some(v) = self.language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

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

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

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

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

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

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

// @@protoc_insertion_point(message:CPlayer_GetProfileItemsEquipped_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetProfileItemsEquipped_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetProfileItemsEquipped_Response.profile_background)
    pub profile_background: ::steam_vent_proto_common::protobuf::MessageField<ProfileItem>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileItemsEquipped_Response.mini_profile_background)
    pub mini_profile_background: ::steam_vent_proto_common::protobuf::MessageField<ProfileItem>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileItemsEquipped_Response.avatar_frame)
    pub avatar_frame: ::steam_vent_proto_common::protobuf::MessageField<ProfileItem>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileItemsEquipped_Response.animated_avatar)
    pub animated_avatar: ::steam_vent_proto_common::protobuf::MessageField<ProfileItem>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileItemsEquipped_Response.profile_modifier)
    pub profile_modifier: ::steam_vent_proto_common::protobuf::MessageField<ProfileItem>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileItemsEquipped_Response.steam_deck_keyboard_skin)
    pub steam_deck_keyboard_skin: ::steam_vent_proto_common::protobuf::MessageField<ProfileItem>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetProfileItemsEquipped_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.profile_background)?;
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.mini_profile_background)?;
                },
                26 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.avatar_frame)?;
                },
                34 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.animated_avatar)?;
                },
                42 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.profile_modifier)?;
                },
                50 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.steam_deck_keyboard_skin)?;
                },
                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.profile_background.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.mini_profile_background.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.avatar_frame.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.animated_avatar.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.profile_modifier.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.steam_deck_keyboard_skin.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.profile_background.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.mini_profile_background.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if let Some(v) = self.avatar_frame.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        if let Some(v) = self.animated_avatar.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        }
        if let Some(v) = self.profile_modifier.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        }
        if let Some(v) = self.steam_deck_keyboard_skin.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.profile_background.clear();
        self.mini_profile_background.clear();
        self.avatar_frame.clear();
        self.animated_avatar.clear();
        self.profile_modifier.clear();
        self.steam_deck_keyboard_skin.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetProfileItemsEquipped_Response {
        static instance: CPlayer_GetProfileItemsEquipped_Response = CPlayer_GetProfileItemsEquipped_Response {
            profile_background: ::steam_vent_proto_common::protobuf::MessageField::none(),
            mini_profile_background: ::steam_vent_proto_common::protobuf::MessageField::none(),
            avatar_frame: ::steam_vent_proto_common::protobuf::MessageField::none(),
            animated_avatar: ::steam_vent_proto_common::protobuf::MessageField::none(),
            profile_modifier: ::steam_vent_proto_common::protobuf::MessageField::none(),
            steam_deck_keyboard_skin: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional uint64 communityitemid = 1;

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

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

    pub fn has_communityitemid(&self) -> bool {
        self.communityitemid.is_some()
    }

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

    // optional uint32 flags = 2;

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetEquippedProfileItemFlags_Request {
    const NAME: &'static str = "CPlayer_SetEquippedProfileItemFlags_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.communityitemid = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.flags = ::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.communityitemid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.flags {
            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.communityitemid {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.flags {
            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() -> CPlayer_SetEquippedProfileItemFlags_Request {
        CPlayer_SetEquippedProfileItemFlags_Request::new()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetEmoticonList_Response {
    const NAME: &'static str = "CPlayer_GetEmoticonList_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.emoticons.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.emoticons {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

/// Nested message and enums of message `CPlayer_GetEmoticonList_Response`
pub mod cplayer_get_emoticon_list_response {
    // @@protoc_insertion_point(message:CPlayer_GetEmoticonList_Response.Emoticon)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Emoticon {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetEmoticonList_Response.Emoticon.name)
        pub name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CPlayer_GetEmoticonList_Response.Emoticon.count)
        pub count: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetEmoticonList_Response.Emoticon.time_last_used)
        pub time_last_used: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetEmoticonList_Response.Emoticon.use_count)
        pub use_count: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetEmoticonList_Response.Emoticon.time_received)
        pub time_received: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetEmoticonList_Response.Emoticon.appid)
        pub appid: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetEmoticonList_Response.Emoticon.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional string name = 1;

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

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

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

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

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

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

        // optional int32 count = 2;

        pub fn count(&self) -> i32 {
            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: i32) {
            self.count = ::std::option::Option::Some(v);
        }

        // optional uint32 time_last_used = 3;

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

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

        pub fn has_time_last_used(&self) -> bool {
            self.time_last_used.is_some()
        }

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

        // optional uint32 use_count = 4;

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

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

        pub fn has_use_count(&self) -> bool {
            self.use_count.is_some()
        }

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

        // optional uint32 time_received = 5;

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

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

        pub fn has_time_received(&self) -> bool {
            self.time_received.is_some()
        }

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

        // optional uint32 appid = 6;

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

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

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

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

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

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

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.name = ::std::option::Option::Some(is.read_string()?);
                    },
                    16 => {
                        self.count = ::std::option::Option::Some(is.read_int32()?);
                    },
                    24 => {
                        self.time_last_used = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    32 => {
                        self.use_count = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    40 => {
                        self.time_received = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    48 => {
                        self.appid = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.name.as_ref() {
                os.write_string(1, v)?;
            }
            if let Some(v) = self.count {
                os.write_int32(2, v)?;
            }
            if let Some(v) = self.time_last_used {
                os.write_uint32(3, v)?;
            }
            if let Some(v) = self.use_count {
                os.write_uint32(4, v)?;
            }
            if let Some(v) = self.time_received {
                os.write_uint32(5, v)?;
            }
            if let Some(v) = self.appid {
                os.write_uint32(6, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

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

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

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

        fn clear(&mut self) {
            self.name = ::std::option::Option::None;
            self.count = ::std::option::Option::None;
            self.time_last_used = ::std::option::Option::None;
            self.use_count = ::std::option::Option::None;
            self.time_received = ::std::option::Option::None;
            self.appid = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Emoticon {
            static instance: Emoticon = Emoticon {
                name: ::std::option::Option::None,
                count: ::std::option::Option::None,
                time_last_used: ::std::option::Option::None,
                use_count: ::std::option::Option::None,
                time_received: ::std::option::Option::None,
                appid: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

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

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

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

    // optional uint64 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 badgeid = 2;

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

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

    pub fn has_badgeid(&self) -> bool {
        self.badgeid.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetCommunityBadgeProgress_Request {
    const NAME: &'static str = "CPlayer_GetCommunityBadgeProgress_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.steamid = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.badgeid = ::std::option::Option::Some(is.read_int32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.steamid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.badgeid {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_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 {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.badgeid {
            os.write_int32(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() -> CPlayer_GetCommunityBadgeProgress_Request {
        CPlayer_GetCommunityBadgeProgress_Request::new()
    }

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

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetCommunityBadgeProgress_Response {
    const NAME: &'static str = "CPlayer_GetCommunityBadgeProgress_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.quests.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.quests {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

/// Nested message and enums of message `CPlayer_GetCommunityBadgeProgress_Response`
pub mod cplayer_get_community_badge_progress_response {
    // @@protoc_insertion_point(message:CPlayer_GetCommunityBadgeProgress_Response.Quest)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Quest {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetCommunityBadgeProgress_Response.Quest.questid)
        pub questid: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetCommunityBadgeProgress_Response.Quest.completed)
        pub completed: ::std::option::Option<bool>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetCommunityBadgeProgress_Response.Quest.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional uint32 questid = 1;

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

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

        pub fn has_questid(&self) -> bool {
            self.questid.is_some()
        }

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

        // optional bool completed = 2;

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

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

        pub fn has_completed(&self) -> bool {
            self.completed.is_some()
        }

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

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

        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.questid = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    16 => {
                        self.completed = ::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.questid {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
            }
            if let Some(v) = self.completed {
                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.questid {
                os.write_uint32(1, v)?;
            }
            if let Some(v) = self.completed {
                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() -> Quest {
            Quest::new()
        }

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

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

// @@protoc_insertion_point(message:CPlayer_GetTopAchievementsForGames_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetTopAchievementsForGames_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Request.language)
    pub language: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Request.max_achievements)
    pub max_achievements: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Request.appids)
    pub appids: ::std::vec::Vec<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetTopAchievementsForGames_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint64 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 string language = 2;

    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())
    }

    // optional uint32 max_achievements = 3;

    pub fn max_achievements(&self) -> u32 {
        self.max_achievements.unwrap_or(0)
    }

    pub fn clear_max_achievements(&mut self) {
        self.max_achievements = ::std::option::Option::None;
    }

    pub fn has_max_achievements(&self) -> bool {
        self.max_achievements.is_some()
    }

    // Param is passed by value, moved
    pub fn set_max_achievements(&mut self, v: u32) {
        self.max_achievements = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetTopAchievementsForGames_Request {
    const NAME: &'static str = "CPlayer_GetTopAchievementsForGames_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.steamid = ::std::option::Option::Some(is.read_uint64()?);
                },
                18 => {
                    self.language = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.max_achievements = ::std::option::Option::Some(is.read_uint32()?);
                },
                34 => {
                    is.read_repeated_packed_uint32_into(&mut self.appids)?;
                },
                32 => {
                    self.appids.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.steamid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.max_achievements {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        for value in &self.appids {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, *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 {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.language.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.max_achievements {
            os.write_uint32(3, v)?;
        }
        for v in &self.appids {
            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() -> CPlayer_GetTopAchievementsForGames_Request {
        CPlayer_GetTopAchievementsForGames_Request::new()
    }

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.language = ::std::option::Option::None;
        self.max_achievements = ::std::option::Option::None;
        self.appids.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetTopAchievementsForGames_Request {
        static instance: CPlayer_GetTopAchievementsForGames_Request = CPlayer_GetTopAchievementsForGames_Request {
            steamid: ::std::option::Option::None,
            language: ::std::option::Option::None,
            max_achievements: ::std::option::Option::None,
            appids: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetTopAchievementsForGames_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetTopAchievementsForGames_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Response.games)
    pub games: ::std::vec::Vec<cplayer_get_top_achievements_for_games_response::Game>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetTopAchievementsForGames_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetTopAchievementsForGames_Response {
    fn default() -> &'a CPlayer_GetTopAchievementsForGames_Response {
        <CPlayer_GetTopAchievementsForGames_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetTopAchievementsForGames_Response {
    pub fn new() -> CPlayer_GetTopAchievementsForGames_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetTopAchievementsForGames_Response {
    const NAME: &'static str = "CPlayer_GetTopAchievementsForGames_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.games.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.games {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.games {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetTopAchievementsForGames_Response {
        CPlayer_GetTopAchievementsForGames_Response::new()
    }

    fn clear(&mut self) {
        self.games.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetTopAchievementsForGames_Response {
        static instance: CPlayer_GetTopAchievementsForGames_Response = CPlayer_GetTopAchievementsForGames_Response {
            games: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CPlayer_GetTopAchievementsForGames_Response`
pub mod cplayer_get_top_achievements_for_games_response {
    // @@protoc_insertion_point(message:CPlayer_GetTopAchievementsForGames_Response.Achievement)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Achievement {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Response.Achievement.statid)
        pub statid: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Response.Achievement.bit)
        pub bit: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Response.Achievement.name)
        pub name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Response.Achievement.desc)
        pub desc: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Response.Achievement.icon)
        pub icon: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Response.Achievement.icon_gray)
        pub icon_gray: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Response.Achievement.hidden)
        pub hidden: ::std::option::Option<bool>,
        // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Response.Achievement.player_percent_unlocked)
        pub player_percent_unlocked: ::std::option::Option<::std::string::String>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetTopAchievementsForGames_Response.Achievement.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

    impl<'a> ::std::default::Default for &'a Achievement {
        fn default() -> &'a Achievement {
            <Achievement as ::steam_vent_proto_common::protobuf::Message>::default_instance()
        }
    }

    impl Achievement {
        pub fn new() -> Achievement {
            ::std::default::Default::default()
        }

        // optional uint32 statid = 1;

        pub fn statid(&self) -> u32 {
            self.statid.unwrap_or(0)
        }

        pub fn clear_statid(&mut self) {
            self.statid = ::std::option::Option::None;
        }

        pub fn has_statid(&self) -> bool {
            self.statid.is_some()
        }

        // Param is passed by value, moved
        pub fn set_statid(&mut self, v: u32) {
            self.statid = ::std::option::Option::Some(v);
        }

        // optional uint32 bit = 2;

        pub fn bit(&self) -> u32 {
            self.bit.unwrap_or(0)
        }

        pub fn clear_bit(&mut self) {
            self.bit = ::std::option::Option::None;
        }

        pub fn has_bit(&self) -> bool {
            self.bit.is_some()
        }

        // Param is passed by value, moved
        pub fn set_bit(&mut self, v: u32) {
            self.bit = ::std::option::Option::Some(v);
        }

        // optional string name = 3;

        pub fn name(&self) -> &str {
            match self.name.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_name(&mut self) {
            self.name = ::std::option::Option::None;
        }

        pub fn has_name(&self) -> bool {
            self.name.is_some()
        }

        // Param is passed by value, moved
        pub fn set_name(&mut self, v: ::std::string::String) {
            self.name = ::std::option::Option::Some(v);
        }

        // Mutable pointer to the field.
        // If field is not initialized, it is initialized with default value first.
        pub fn mut_name(&mut self) -> &mut ::std::string::String {
            if self.name.is_none() {
                self.name = ::std::option::Option::Some(::std::string::String::new());
            }
            self.name.as_mut().unwrap()
        }

        // Take field
        pub fn take_name(&mut self) -> ::std::string::String {
            self.name.take().unwrap_or_else(|| ::std::string::String::new())
        }

        // optional string desc = 4;

        pub fn desc(&self) -> &str {
            match self.desc.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_desc(&mut self) {
            self.desc = ::std::option::Option::None;
        }

        pub fn has_desc(&self) -> bool {
            self.desc.is_some()
        }

        // Param is passed by value, moved
        pub fn set_desc(&mut self, v: ::std::string::String) {
            self.desc = ::std::option::Option::Some(v);
        }

        // Mutable pointer to the field.
        // If field is not initialized, it is initialized with default value first.
        pub fn mut_desc(&mut self) -> &mut ::std::string::String {
            if self.desc.is_none() {
                self.desc = ::std::option::Option::Some(::std::string::String::new());
            }
            self.desc.as_mut().unwrap()
        }

        // Take field
        pub fn take_desc(&mut self) -> ::std::string::String {
            self.desc.take().unwrap_or_else(|| ::std::string::String::new())
        }

        // optional string icon = 5;

        pub fn icon(&self) -> &str {
            match self.icon.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_icon(&mut self) {
            self.icon = ::std::option::Option::None;
        }

        pub fn has_icon(&self) -> bool {
            self.icon.is_some()
        }

        // Param is passed by value, moved
        pub fn set_icon(&mut self, v: ::std::string::String) {
            self.icon = ::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_icon(&mut self) -> &mut ::std::string::String {
            if self.icon.is_none() {
                self.icon = ::std::option::Option::Some(::std::string::String::new());
            }
            self.icon.as_mut().unwrap()
        }

        // Take field
        pub fn take_icon(&mut self) -> ::std::string::String {
            self.icon.take().unwrap_or_else(|| ::std::string::String::new())
        }

        // optional string icon_gray = 6;

        pub fn icon_gray(&self) -> &str {
            match self.icon_gray.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_icon_gray(&mut self) {
            self.icon_gray = ::std::option::Option::None;
        }

        pub fn has_icon_gray(&self) -> bool {
            self.icon_gray.is_some()
        }

        // Param is passed by value, moved
        pub fn set_icon_gray(&mut self, v: ::std::string::String) {
            self.icon_gray = ::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_icon_gray(&mut self) -> &mut ::std::string::String {
            if self.icon_gray.is_none() {
                self.icon_gray = ::std::option::Option::Some(::std::string::String::new());
            }
            self.icon_gray.as_mut().unwrap()
        }

        // Take field
        pub fn take_icon_gray(&mut self) -> ::std::string::String {
            self.icon_gray.take().unwrap_or_else(|| ::std::string::String::new())
        }

        // optional bool hidden = 7;

        pub fn hidden(&self) -> bool {
            self.hidden.unwrap_or(false)
        }

        pub fn clear_hidden(&mut self) {
            self.hidden = ::std::option::Option::None;
        }

        pub fn has_hidden(&self) -> bool {
            self.hidden.is_some()
        }

        // Param is passed by value, moved
        pub fn set_hidden(&mut self, v: bool) {
            self.hidden = ::std::option::Option::Some(v);
        }

        // optional string player_percent_unlocked = 8;

        pub fn player_percent_unlocked(&self) -> &str {
            match self.player_percent_unlocked.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_player_percent_unlocked(&mut self) {
            self.player_percent_unlocked = ::std::option::Option::None;
        }

        pub fn has_player_percent_unlocked(&self) -> bool {
            self.player_percent_unlocked.is_some()
        }

        // Param is passed by value, moved
        pub fn set_player_percent_unlocked(&mut self, v: ::std::string::String) {
            self.player_percent_unlocked = ::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_player_percent_unlocked(&mut self) -> &mut ::std::string::String {
            if self.player_percent_unlocked.is_none() {
                self.player_percent_unlocked = ::std::option::Option::Some(::std::string::String::new());
            }
            self.player_percent_unlocked.as_mut().unwrap()
        }

        // Take field
        pub fn take_player_percent_unlocked(&mut self) -> ::std::string::String {
            self.player_percent_unlocked.take().unwrap_or_else(|| ::std::string::String::new())
        }
    }

    impl ::steam_vent_proto_common::protobuf::Message for Achievement {
        const NAME: &'static str = "Achievement";

        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.statid = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    16 => {
                        self.bit = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    26 => {
                        self.name = ::std::option::Option::Some(is.read_string()?);
                    },
                    34 => {
                        self.desc = ::std::option::Option::Some(is.read_string()?);
                    },
                    42 => {
                        self.icon = ::std::option::Option::Some(is.read_string()?);
                    },
                    50 => {
                        self.icon_gray = ::std::option::Option::Some(is.read_string()?);
                    },
                    56 => {
                        self.hidden = ::std::option::Option::Some(is.read_bool()?);
                    },
                    66 => {
                        self.player_percent_unlocked = ::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.statid {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
            }
            if let Some(v) = self.bit {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
            }
            if let Some(v) = self.name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
            }
            if let Some(v) = self.desc.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
            }
            if let Some(v) = self.icon.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &v);
            }
            if let Some(v) = self.icon_gray.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
            }
            if let Some(v) = self.hidden {
                my_size += 1 + 1;
            }
            if let Some(v) = self.player_percent_unlocked.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.statid {
                os.write_uint32(1, v)?;
            }
            if let Some(v) = self.bit {
                os.write_uint32(2, v)?;
            }
            if let Some(v) = self.name.as_ref() {
                os.write_string(3, v)?;
            }
            if let Some(v) = self.desc.as_ref() {
                os.write_string(4, v)?;
            }
            if let Some(v) = self.icon.as_ref() {
                os.write_string(5, v)?;
            }
            if let Some(v) = self.icon_gray.as_ref() {
                os.write_string(6, v)?;
            }
            if let Some(v) = self.hidden {
                os.write_bool(7, v)?;
            }
            if let Some(v) = self.player_percent_unlocked.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() -> Achievement {
            Achievement::new()
        }

        fn clear(&mut self) {
            self.statid = ::std::option::Option::None;
            self.bit = ::std::option::Option::None;
            self.name = ::std::option::Option::None;
            self.desc = ::std::option::Option::None;
            self.icon = ::std::option::Option::None;
            self.icon_gray = ::std::option::Option::None;
            self.hidden = ::std::option::Option::None;
            self.player_percent_unlocked = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Achievement {
            static instance: Achievement = Achievement {
                statid: ::std::option::Option::None,
                bit: ::std::option::Option::None,
                name: ::std::option::Option::None,
                desc: ::std::option::Option::None,
                icon: ::std::option::Option::None,
                icon_gray: ::std::option::Option::None,
                hidden: ::std::option::Option::None,
                player_percent_unlocked: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:CPlayer_GetTopAchievementsForGames_Response.Game)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Game {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Response.Game.appid)
        pub appid: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Response.Game.total_achievements)
        pub total_achievements: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetTopAchievementsForGames_Response.Game.achievements)
        pub achievements: ::std::vec::Vec<Achievement>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetTopAchievementsForGames_Response.Game.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

    impl<'a> ::std::default::Default for &'a Game {
        fn default() -> &'a Game {
            <Game as ::steam_vent_proto_common::protobuf::Message>::default_instance()
        }
    }

    impl Game {
        pub fn new() -> Game {
            ::std::default::Default::default()
        }

        // optional uint32 appid = 1;

        pub fn appid(&self) -> u32 {
            self.appid.unwrap_or(0)
        }

        pub fn clear_appid(&mut self) {
            self.appid = ::std::option::Option::None;
        }

        pub fn has_appid(&self) -> bool {
            self.appid.is_some()
        }

        // Param is passed by value, moved
        pub fn set_appid(&mut self, v: u32) {
            self.appid = ::std::option::Option::Some(v);
        }

        // optional uint32 total_achievements = 2;

        pub fn total_achievements(&self) -> u32 {
            self.total_achievements.unwrap_or(0)
        }

        pub fn clear_total_achievements(&mut self) {
            self.total_achievements = ::std::option::Option::None;
        }

        pub fn has_total_achievements(&self) -> bool {
            self.total_achievements.is_some()
        }

        // Param is passed by value, moved
        pub fn set_total_achievements(&mut self, v: u32) {
            self.total_achievements = ::std::option::Option::Some(v);
        }
    }

    impl ::steam_vent_proto_common::protobuf::Message for Game {
        const NAME: &'static str = "Game";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.appid = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    16 => {
                        self.total_achievements = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    26 => {
                        self.achievements.push(is.read_message()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if let Some(v) = self.appid {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
            }
            if let Some(v) = self.total_achievements {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
            }
            for value in &self.achievements {
                let len = value.compute_size();
                my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.appid {
                os.write_uint32(1, v)?;
            }
            if let Some(v) = self.total_achievements {
                os.write_uint32(2, v)?;
            }
            for v in &self.achievements {
                ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
            };
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
            &mut self.special_fields
        }

        fn new() -> Game {
            Game::new()
        }

        fn clear(&mut self) {
            self.appid = ::std::option::Option::None;
            self.total_achievements = ::std::option::Option::None;
            self.achievements.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Game {
            static instance: Game = Game {
                appid: ::std::option::Option::None,
                total_achievements: ::std::option::Option::None,
                achievements: ::std::vec::Vec::new(),
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CPlayer_GetAchievementsProgress_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetAchievementsProgress_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetAchievementsProgress_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CPlayer_GetAchievementsProgress_Request.language)
    pub language: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CPlayer_GetAchievementsProgress_Request.appids)
    pub appids: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CPlayer_GetAchievementsProgress_Request.include_unvetted_apps)
    pub include_unvetted_apps: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetAchievementsProgress_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetAchievementsProgress_Request {
    fn default() -> &'a CPlayer_GetAchievementsProgress_Request {
        <CPlayer_GetAchievementsProgress_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetAchievementsProgress_Request {
    pub fn new() -> CPlayer_GetAchievementsProgress_Request {
        ::std::default::Default::default()
    }

    // optional uint64 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 string language = 2;

    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())
    }

    // optional bool include_unvetted_apps = 4;

    pub fn include_unvetted_apps(&self) -> bool {
        self.include_unvetted_apps.unwrap_or(false)
    }

    pub fn clear_include_unvetted_apps(&mut self) {
        self.include_unvetted_apps = ::std::option::Option::None;
    }

    pub fn has_include_unvetted_apps(&self) -> bool {
        self.include_unvetted_apps.is_some()
    }

    // Param is passed by value, moved
    pub fn set_include_unvetted_apps(&mut self, v: bool) {
        self.include_unvetted_apps = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetAchievementsProgress_Request {
    const NAME: &'static str = "CPlayer_GetAchievementsProgress_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.steamid = ::std::option::Option::Some(is.read_uint64()?);
                },
                18 => {
                    self.language = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    is.read_repeated_packed_uint32_into(&mut self.appids)?;
                },
                24 => {
                    self.appids.push(is.read_uint32()?);
                },
                32 => {
                    self.include_unvetted_apps = ::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 += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        for value in &self.appids {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, *value);
        };
        if let Some(v) = self.include_unvetted_apps {
            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_uint64(1, v)?;
        }
        if let Some(v) = self.language.as_ref() {
            os.write_string(2, v)?;
        }
        for v in &self.appids {
            os.write_uint32(3, *v)?;
        };
        if let Some(v) = self.include_unvetted_apps {
            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() -> CPlayer_GetAchievementsProgress_Request {
        CPlayer_GetAchievementsProgress_Request::new()
    }

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.language = ::std::option::Option::None;
        self.appids.clear();
        self.include_unvetted_apps = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetAchievementsProgress_Request {
        static instance: CPlayer_GetAchievementsProgress_Request = CPlayer_GetAchievementsProgress_Request {
            steamid: ::std::option::Option::None,
            language: ::std::option::Option::None,
            appids: ::std::vec::Vec::new(),
            include_unvetted_apps: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetAchievementsProgress_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetAchievementsProgress_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetAchievementsProgress_Response.achievement_progress)
    pub achievement_progress: ::std::vec::Vec<cplayer_get_achievements_progress_response::AchievementProgress>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetAchievementsProgress_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetAchievementsProgress_Response {
    fn default() -> &'a CPlayer_GetAchievementsProgress_Response {
        <CPlayer_GetAchievementsProgress_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetAchievementsProgress_Response {
    pub fn new() -> CPlayer_GetAchievementsProgress_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetAchievementsProgress_Response {
    const NAME: &'static str = "CPlayer_GetAchievementsProgress_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.achievement_progress.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.achievement_progress {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.achievement_progress {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetAchievementsProgress_Response {
        CPlayer_GetAchievementsProgress_Response::new()
    }

    fn clear(&mut self) {
        self.achievement_progress.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetAchievementsProgress_Response {
        static instance: CPlayer_GetAchievementsProgress_Response = CPlayer_GetAchievementsProgress_Response {
            achievement_progress: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CPlayer_GetAchievementsProgress_Response`
pub mod cplayer_get_achievements_progress_response {
    // @@protoc_insertion_point(message:CPlayer_GetAchievementsProgress_Response.AchievementProgress)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct AchievementProgress {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetAchievementsProgress_Response.AchievementProgress.appid)
        pub appid: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetAchievementsProgress_Response.AchievementProgress.unlocked)
        pub unlocked: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetAchievementsProgress_Response.AchievementProgress.total)
        pub total: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetAchievementsProgress_Response.AchievementProgress.percentage)
        pub percentage: ::std::option::Option<f32>,
        // @@protoc_insertion_point(field:CPlayer_GetAchievementsProgress_Response.AchievementProgress.all_unlocked)
        pub all_unlocked: ::std::option::Option<bool>,
        // @@protoc_insertion_point(field:CPlayer_GetAchievementsProgress_Response.AchievementProgress.cache_time)
        pub cache_time: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetAchievementsProgress_Response.AchievementProgress.vetted)
        pub vetted: ::std::option::Option<bool>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetAchievementsProgress_Response.AchievementProgress.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

    impl<'a> ::std::default::Default for &'a AchievementProgress {
        fn default() -> &'a AchievementProgress {
            <AchievementProgress as ::steam_vent_proto_common::protobuf::Message>::default_instance()
        }
    }

    impl AchievementProgress {
        pub fn new() -> AchievementProgress {
            ::std::default::Default::default()
        }

        // optional uint32 appid = 1;

        pub fn appid(&self) -> u32 {
            self.appid.unwrap_or(0)
        }

        pub fn clear_appid(&mut self) {
            self.appid = ::std::option::Option::None;
        }

        pub fn has_appid(&self) -> bool {
            self.appid.is_some()
        }

        // Param is passed by value, moved
        pub fn set_appid(&mut self, v: u32) {
            self.appid = ::std::option::Option::Some(v);
        }

        // optional uint32 unlocked = 2;

        pub fn unlocked(&self) -> u32 {
            self.unlocked.unwrap_or(0)
        }

        pub fn clear_unlocked(&mut self) {
            self.unlocked = ::std::option::Option::None;
        }

        pub fn has_unlocked(&self) -> bool {
            self.unlocked.is_some()
        }

        // Param is passed by value, moved
        pub fn set_unlocked(&mut self, v: u32) {
            self.unlocked = ::std::option::Option::Some(v);
        }

        // optional uint32 total = 3;

        pub fn total(&self) -> u32 {
            self.total.unwrap_or(0)
        }

        pub fn clear_total(&mut self) {
            self.total = ::std::option::Option::None;
        }

        pub fn has_total(&self) -> bool {
            self.total.is_some()
        }

        // Param is passed by value, moved
        pub fn set_total(&mut self, v: u32) {
            self.total = ::std::option::Option::Some(v);
        }

        // optional float percentage = 4;

        pub fn percentage(&self) -> f32 {
            self.percentage.unwrap_or(0.)
        }

        pub fn clear_percentage(&mut self) {
            self.percentage = ::std::option::Option::None;
        }

        pub fn has_percentage(&self) -> bool {
            self.percentage.is_some()
        }

        // Param is passed by value, moved
        pub fn set_percentage(&mut self, v: f32) {
            self.percentage = ::std::option::Option::Some(v);
        }

        // optional bool all_unlocked = 5;

        pub fn all_unlocked(&self) -> bool {
            self.all_unlocked.unwrap_or(false)
        }

        pub fn clear_all_unlocked(&mut self) {
            self.all_unlocked = ::std::option::Option::None;
        }

        pub fn has_all_unlocked(&self) -> bool {
            self.all_unlocked.is_some()
        }

        // Param is passed by value, moved
        pub fn set_all_unlocked(&mut self, v: bool) {
            self.all_unlocked = ::std::option::Option::Some(v);
        }

        // optional uint32 cache_time = 6;

        pub fn cache_time(&self) -> u32 {
            self.cache_time.unwrap_or(0)
        }

        pub fn clear_cache_time(&mut self) {
            self.cache_time = ::std::option::Option::None;
        }

        pub fn has_cache_time(&self) -> bool {
            self.cache_time.is_some()
        }

        // Param is passed by value, moved
        pub fn set_cache_time(&mut self, v: u32) {
            self.cache_time = ::std::option::Option::Some(v);
        }

        // optional bool vetted = 7;

        pub fn vetted(&self) -> bool {
            self.vetted.unwrap_or(false)
        }

        pub fn clear_vetted(&mut self) {
            self.vetted = ::std::option::Option::None;
        }

        pub fn has_vetted(&self) -> bool {
            self.vetted.is_some()
        }

        // Param is passed by value, moved
        pub fn set_vetted(&mut self, v: bool) {
            self.vetted = ::std::option::Option::Some(v);
        }
    }

    impl ::steam_vent_proto_common::protobuf::Message for AchievementProgress {
        const NAME: &'static str = "AchievementProgress";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.appid = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    16 => {
                        self.unlocked = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    24 => {
                        self.total = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    37 => {
                        self.percentage = ::std::option::Option::Some(is.read_float()?);
                    },
                    40 => {
                        self.all_unlocked = ::std::option::Option::Some(is.read_bool()?);
                    },
                    48 => {
                        self.cache_time = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    56 => {
                        self.vetted = ::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.appid {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
            }
            if let Some(v) = self.unlocked {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
            }
            if let Some(v) = self.total {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
            }
            if let Some(v) = self.percentage {
                my_size += 1 + 4;
            }
            if let Some(v) = self.all_unlocked {
                my_size += 1 + 1;
            }
            if let Some(v) = self.cache_time {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
            }
            if let Some(v) = self.vetted {
                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.appid {
                os.write_uint32(1, v)?;
            }
            if let Some(v) = self.unlocked {
                os.write_uint32(2, v)?;
            }
            if let Some(v) = self.total {
                os.write_uint32(3, v)?;
            }
            if let Some(v) = self.percentage {
                os.write_float(4, v)?;
            }
            if let Some(v) = self.all_unlocked {
                os.write_bool(5, v)?;
            }
            if let Some(v) = self.cache_time {
                os.write_uint32(6, v)?;
            }
            if let Some(v) = self.vetted {
                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() -> AchievementProgress {
            AchievementProgress::new()
        }

        fn clear(&mut self) {
            self.appid = ::std::option::Option::None;
            self.unlocked = ::std::option::Option::None;
            self.total = ::std::option::Option::None;
            self.percentage = ::std::option::Option::None;
            self.all_unlocked = ::std::option::Option::None;
            self.cache_time = ::std::option::Option::None;
            self.vetted = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static AchievementProgress {
            static instance: AchievementProgress = AchievementProgress {
                appid: ::std::option::Option::None,
                unlocked: ::std::option::Option::None,
                total: ::std::option::Option::None,
                percentage: ::std::option::Option::None,
                all_unlocked: ::std::option::Option::None,
                cache_time: ::std::option::Option::None,
                vetted: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CPlayer_GetGameAchievements_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetGameAchievements_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetGameAchievements_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_GetGameAchievements_Request.language)
    pub language: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetGameAchievements_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetGameAchievements_Request {
    fn default() -> &'a CPlayer_GetGameAchievements_Request {
        <CPlayer_GetGameAchievements_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetGameAchievements_Request {
    pub fn new() -> CPlayer_GetGameAchievements_Request {
        ::std::default::Default::default()
    }

    // optional uint32 appid = 1;

    pub fn appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }

    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

    pub fn has_appid(&self) -> bool {
        self.appid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_appid(&mut self, v: u32) {
        self.appid = ::std::option::Option::Some(v);
    }

    // optional string language = 2;

    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 CPlayer_GetGameAchievements_Request {
    const NAME: &'static str = "CPlayer_GetGameAchievements_Request";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                18 => {
                    self.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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.language.as_ref() {
            os.write_string(2, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetGameAchievements_Request {
        CPlayer_GetGameAchievements_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.language = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetGameAchievements_Request {
        static instance: CPlayer_GetGameAchievements_Request = CPlayer_GetGameAchievements_Request {
            appid: ::std::option::Option::None,
            language: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetGameAchievements_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetGameAchievements_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetGameAchievements_Response.achievements)
    pub achievements: ::std::vec::Vec<cplayer_get_game_achievements_response::Achievement>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetGameAchievements_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetGameAchievements_Response {
    fn default() -> &'a CPlayer_GetGameAchievements_Response {
        <CPlayer_GetGameAchievements_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetGameAchievements_Response {
    pub fn new() -> CPlayer_GetGameAchievements_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetGameAchievements_Response {
    const NAME: &'static str = "CPlayer_GetGameAchievements_Response";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.achievements.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.achievements {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.achievements {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetGameAchievements_Response {
        CPlayer_GetGameAchievements_Response::new()
    }

    fn clear(&mut self) {
        self.achievements.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetGameAchievements_Response {
        static instance: CPlayer_GetGameAchievements_Response = CPlayer_GetGameAchievements_Response {
            achievements: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CPlayer_GetGameAchievements_Response`
pub mod cplayer_get_game_achievements_response {
    // @@protoc_insertion_point(message:CPlayer_GetGameAchievements_Response.Achievement)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Achievement {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetGameAchievements_Response.Achievement.internal_name)
        pub internal_name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CPlayer_GetGameAchievements_Response.Achievement.localized_name)
        pub localized_name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CPlayer_GetGameAchievements_Response.Achievement.localized_desc)
        pub localized_desc: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CPlayer_GetGameAchievements_Response.Achievement.icon)
        pub icon: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CPlayer_GetGameAchievements_Response.Achievement.icon_gray)
        pub icon_gray: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CPlayer_GetGameAchievements_Response.Achievement.hidden)
        pub hidden: ::std::option::Option<bool>,
        // @@protoc_insertion_point(field:CPlayer_GetGameAchievements_Response.Achievement.player_percent_unlocked)
        pub player_percent_unlocked: ::std::option::Option<::std::string::String>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetGameAchievements_Response.Achievement.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

    impl<'a> ::std::default::Default for &'a Achievement {
        fn default() -> &'a Achievement {
            <Achievement as ::steam_vent_proto_common::protobuf::Message>::default_instance()
        }
    }

    impl Achievement {
        pub fn new() -> Achievement {
            ::std::default::Default::default()
        }

        // optional string internal_name = 1;

        pub fn internal_name(&self) -> &str {
            match self.internal_name.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_internal_name(&mut self) {
            self.internal_name = ::std::option::Option::None;
        }

        pub fn has_internal_name(&self) -> bool {
            self.internal_name.is_some()
        }

        // Param is passed by value, moved
        pub fn set_internal_name(&mut self, v: ::std::string::String) {
            self.internal_name = ::std::option::Option::Some(v);
        }

        // Mutable pointer to the field.
        // If field is not initialized, it is initialized with default value first.
        pub fn mut_internal_name(&mut self) -> &mut ::std::string::String {
            if self.internal_name.is_none() {
                self.internal_name = ::std::option::Option::Some(::std::string::String::new());
            }
            self.internal_name.as_mut().unwrap()
        }

        // Take field
        pub fn take_internal_name(&mut self) -> ::std::string::String {
            self.internal_name.take().unwrap_or_else(|| ::std::string::String::new())
        }

        // optional string localized_name = 2;

        pub fn localized_name(&self) -> &str {
            match self.localized_name.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_localized_name(&mut self) {
            self.localized_name = ::std::option::Option::None;
        }

        pub fn has_localized_name(&self) -> bool {
            self.localized_name.is_some()
        }

        // Param is passed by value, moved
        pub fn set_localized_name(&mut self, v: ::std::string::String) {
            self.localized_name = ::std::option::Option::Some(v);
        }

        // Mutable pointer to the field.
        // If field is not initialized, it is initialized with default value first.
        pub fn mut_localized_name(&mut self) -> &mut ::std::string::String {
            if self.localized_name.is_none() {
                self.localized_name = ::std::option::Option::Some(::std::string::String::new());
            }
            self.localized_name.as_mut().unwrap()
        }

        // Take field
        pub fn take_localized_name(&mut self) -> ::std::string::String {
            self.localized_name.take().unwrap_or_else(|| ::std::string::String::new())
        }

        // optional string localized_desc = 3;

        pub fn localized_desc(&self) -> &str {
            match self.localized_desc.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_localized_desc(&mut self) {
            self.localized_desc = ::std::option::Option::None;
        }

        pub fn has_localized_desc(&self) -> bool {
            self.localized_desc.is_some()
        }

        // Param is passed by value, moved
        pub fn set_localized_desc(&mut self, v: ::std::string::String) {
            self.localized_desc = ::std::option::Option::Some(v);
        }

        // Mutable pointer to the field.
        // If field is not initialized, it is initialized with default value first.
        pub fn mut_localized_desc(&mut self) -> &mut ::std::string::String {
            if self.localized_desc.is_none() {
                self.localized_desc = ::std::option::Option::Some(::std::string::String::new());
            }
            self.localized_desc.as_mut().unwrap()
        }

        // Take field
        pub fn take_localized_desc(&mut self) -> ::std::string::String {
            self.localized_desc.take().unwrap_or_else(|| ::std::string::String::new())
        }

        // optional string icon = 4;

        pub fn icon(&self) -> &str {
            match self.icon.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_icon(&mut self) {
            self.icon = ::std::option::Option::None;
        }

        pub fn has_icon(&self) -> bool {
            self.icon.is_some()
        }

        // Param is passed by value, moved
        pub fn set_icon(&mut self, v: ::std::string::String) {
            self.icon = ::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_icon(&mut self) -> &mut ::std::string::String {
            if self.icon.is_none() {
                self.icon = ::std::option::Option::Some(::std::string::String::new());
            }
            self.icon.as_mut().unwrap()
        }

        // Take field
        pub fn take_icon(&mut self) -> ::std::string::String {
            self.icon.take().unwrap_or_else(|| ::std::string::String::new())
        }

        // optional string icon_gray = 5;

        pub fn icon_gray(&self) -> &str {
            match self.icon_gray.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_icon_gray(&mut self) {
            self.icon_gray = ::std::option::Option::None;
        }

        pub fn has_icon_gray(&self) -> bool {
            self.icon_gray.is_some()
        }

        // Param is passed by value, moved
        pub fn set_icon_gray(&mut self, v: ::std::string::String) {
            self.icon_gray = ::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_icon_gray(&mut self) -> &mut ::std::string::String {
            if self.icon_gray.is_none() {
                self.icon_gray = ::std::option::Option::Some(::std::string::String::new());
            }
            self.icon_gray.as_mut().unwrap()
        }

        // Take field
        pub fn take_icon_gray(&mut self) -> ::std::string::String {
            self.icon_gray.take().unwrap_or_else(|| ::std::string::String::new())
        }

        // optional bool hidden = 6;

        pub fn hidden(&self) -> bool {
            self.hidden.unwrap_or(false)
        }

        pub fn clear_hidden(&mut self) {
            self.hidden = ::std::option::Option::None;
        }

        pub fn has_hidden(&self) -> bool {
            self.hidden.is_some()
        }

        // Param is passed by value, moved
        pub fn set_hidden(&mut self, v: bool) {
            self.hidden = ::std::option::Option::Some(v);
        }

        // optional string player_percent_unlocked = 7;

        pub fn player_percent_unlocked(&self) -> &str {
            match self.player_percent_unlocked.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_player_percent_unlocked(&mut self) {
            self.player_percent_unlocked = ::std::option::Option::None;
        }

        pub fn has_player_percent_unlocked(&self) -> bool {
            self.player_percent_unlocked.is_some()
        }

        // Param is passed by value, moved
        pub fn set_player_percent_unlocked(&mut self, v: ::std::string::String) {
            self.player_percent_unlocked = ::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_player_percent_unlocked(&mut self) -> &mut ::std::string::String {
            if self.player_percent_unlocked.is_none() {
                self.player_percent_unlocked = ::std::option::Option::Some(::std::string::String::new());
            }
            self.player_percent_unlocked.as_mut().unwrap()
        }

        // Take field
        pub fn take_player_percent_unlocked(&mut self) -> ::std::string::String {
            self.player_percent_unlocked.take().unwrap_or_else(|| ::std::string::String::new())
        }
    }

    impl ::steam_vent_proto_common::protobuf::Message for Achievement {
        const NAME: &'static str = "Achievement";

        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.internal_name = ::std::option::Option::Some(is.read_string()?);
                    },
                    18 => {
                        self.localized_name = ::std::option::Option::Some(is.read_string()?);
                    },
                    26 => {
                        self.localized_desc = ::std::option::Option::Some(is.read_string()?);
                    },
                    34 => {
                        self.icon = ::std::option::Option::Some(is.read_string()?);
                    },
                    42 => {
                        self.icon_gray = ::std::option::Option::Some(is.read_string()?);
                    },
                    48 => {
                        self.hidden = ::std::option::Option::Some(is.read_bool()?);
                    },
                    58 => {
                        self.player_percent_unlocked = ::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.internal_name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
            }
            if let Some(v) = self.localized_name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
            }
            if let Some(v) = self.localized_desc.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
            }
            if let Some(v) = self.icon.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
            }
            if let Some(v) = self.icon_gray.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &v);
            }
            if let Some(v) = self.hidden {
                my_size += 1 + 1;
            }
            if let Some(v) = self.player_percent_unlocked.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.internal_name.as_ref() {
                os.write_string(1, v)?;
            }
            if let Some(v) = self.localized_name.as_ref() {
                os.write_string(2, v)?;
            }
            if let Some(v) = self.localized_desc.as_ref() {
                os.write_string(3, v)?;
            }
            if let Some(v) = self.icon.as_ref() {
                os.write_string(4, v)?;
            }
            if let Some(v) = self.icon_gray.as_ref() {
                os.write_string(5, v)?;
            }
            if let Some(v) = self.hidden {
                os.write_bool(6, v)?;
            }
            if let Some(v) = self.player_percent_unlocked.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() -> Achievement {
            Achievement::new()
        }

        fn clear(&mut self) {
            self.internal_name = ::std::option::Option::None;
            self.localized_name = ::std::option::Option::None;
            self.localized_desc = ::std::option::Option::None;
            self.icon = ::std::option::Option::None;
            self.icon_gray = ::std::option::Option::None;
            self.hidden = ::std::option::Option::None;
            self.player_percent_unlocked = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Achievement {
            static instance: Achievement = Achievement {
                internal_name: ::std::option::Option::None,
                localized_name: ::std::option::Option::None,
                localized_desc: ::std::option::Option::None,
                icon: ::std::option::Option::None,
                icon_gray: ::std::option::Option::None,
                hidden: ::std::option::Option::None,
                player_percent_unlocked: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CPlayer_GetFavoriteBadge_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetFavoriteBadge_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetFavoriteBadge_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetFavoriteBadge_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetFavoriteBadge_Request {
    fn default() -> &'a CPlayer_GetFavoriteBadge_Request {
        <CPlayer_GetFavoriteBadge_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetFavoriteBadge_Request {
    pub fn new() -> CPlayer_GetFavoriteBadge_Request {
        ::std::default::Default::default()
    }

    // optional uint64 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 CPlayer_GetFavoriteBadge_Request {
    const NAME: &'static str = "CPlayer_GetFavoriteBadge_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.steamid = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.steamid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.steamid {
            os.write_uint64(1, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetFavoriteBadge_Request {
        CPlayer_GetFavoriteBadge_Request::new()
    }

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetFavoriteBadge_Request {
        static instance: CPlayer_GetFavoriteBadge_Request = CPlayer_GetFavoriteBadge_Request {
            steamid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetFavoriteBadge_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetFavoriteBadge_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetFavoriteBadge_Response.has_favorite_badge)
    pub has_favorite_badge: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CPlayer_GetFavoriteBadge_Response.badgeid)
    pub badgeid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_GetFavoriteBadge_Response.communityitemid)
    pub communityitemid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CPlayer_GetFavoriteBadge_Response.item_type)
    pub item_type: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_GetFavoriteBadge_Response.border_color)
    pub border_color: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_GetFavoriteBadge_Response.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_GetFavoriteBadge_Response.level)
    pub level: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetFavoriteBadge_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetFavoriteBadge_Response {
    fn default() -> &'a CPlayer_GetFavoriteBadge_Response {
        <CPlayer_GetFavoriteBadge_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetFavoriteBadge_Response {
    pub fn new() -> CPlayer_GetFavoriteBadge_Response {
        ::std::default::Default::default()
    }

    // optional bool has_favorite_badge = 1;

    pub fn has_favorite_badge(&self) -> bool {
        self.has_favorite_badge.unwrap_or(false)
    }

    pub fn clear_has_favorite_badge(&mut self) {
        self.has_favorite_badge = ::std::option::Option::None;
    }

    pub fn has_has_favorite_badge(&self) -> bool {
        self.has_favorite_badge.is_some()
    }

    // Param is passed by value, moved
    pub fn set_has_favorite_badge(&mut self, v: bool) {
        self.has_favorite_badge = ::std::option::Option::Some(v);
    }

    // optional uint32 badgeid = 2;

    pub fn badgeid(&self) -> u32 {
        self.badgeid.unwrap_or(0)
    }

    pub fn clear_badgeid(&mut self) {
        self.badgeid = ::std::option::Option::None;
    }

    pub fn has_badgeid(&self) -> bool {
        self.badgeid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_badgeid(&mut self, v: u32) {
        self.badgeid = ::std::option::Option::Some(v);
    }

    // optional uint64 communityitemid = 3;

    pub fn communityitemid(&self) -> u64 {
        self.communityitemid.unwrap_or(0)
    }

    pub fn clear_communityitemid(&mut self) {
        self.communityitemid = ::std::option::Option::None;
    }

    pub fn has_communityitemid(&self) -> bool {
        self.communityitemid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_communityitemid(&mut self, v: u64) {
        self.communityitemid = ::std::option::Option::Some(v);
    }

    // optional uint32 item_type = 4;

    pub fn item_type(&self) -> u32 {
        self.item_type.unwrap_or(0)
    }

    pub fn clear_item_type(&mut self) {
        self.item_type = ::std::option::Option::None;
    }

    pub fn has_item_type(&self) -> bool {
        self.item_type.is_some()
    }

    // Param is passed by value, moved
    pub fn set_item_type(&mut self, v: u32) {
        self.item_type = ::std::option::Option::Some(v);
    }

    // optional uint32 border_color = 5;

    pub fn border_color(&self) -> u32 {
        self.border_color.unwrap_or(0)
    }

    pub fn clear_border_color(&mut self) {
        self.border_color = ::std::option::Option::None;
    }

    pub fn has_border_color(&self) -> bool {
        self.border_color.is_some()
    }

    // Param is passed by value, moved
    pub fn set_border_color(&mut self, v: u32) {
        self.border_color = ::std::option::Option::Some(v);
    }

    // optional uint32 appid = 6;

    pub fn appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }

    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

    pub fn has_appid(&self) -> bool {
        self.appid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_appid(&mut self, v: u32) {
        self.appid = ::std::option::Option::Some(v);
    }

    // optional uint32 level = 7;

    pub fn level(&self) -> u32 {
        self.level.unwrap_or(0)
    }

    pub fn clear_level(&mut self) {
        self.level = ::std::option::Option::None;
    }

    pub fn has_level(&self) -> bool {
        self.level.is_some()
    }

    // Param is passed by value, moved
    pub fn set_level(&mut self, v: u32) {
        self.level = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetFavoriteBadge_Response {
    const NAME: &'static str = "CPlayer_GetFavoriteBadge_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.has_favorite_badge = ::std::option::Option::Some(is.read_bool()?);
                },
                16 => {
                    self.badgeid = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.communityitemid = ::std::option::Option::Some(is.read_uint64()?);
                },
                32 => {
                    self.item_type = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.border_color = ::std::option::Option::Some(is.read_uint32()?);
                },
                48 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                56 => {
                    self.level = ::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.has_favorite_badge {
            my_size += 1 + 1;
        }
        if let Some(v) = self.badgeid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.communityitemid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
        }
        if let Some(v) = self.item_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.border_color {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.level {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.has_favorite_badge {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.badgeid {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.communityitemid {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.item_type {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.border_color {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.level {
            os.write_uint32(7, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetFavoriteBadge_Response {
        CPlayer_GetFavoriteBadge_Response::new()
    }

    fn clear(&mut self) {
        self.has_favorite_badge = ::std::option::Option::None;
        self.badgeid = ::std::option::Option::None;
        self.communityitemid = ::std::option::Option::None;
        self.item_type = ::std::option::Option::None;
        self.border_color = ::std::option::Option::None;
        self.appid = ::std::option::Option::None;
        self.level = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetFavoriteBadge_Response {
        static instance: CPlayer_GetFavoriteBadge_Response = CPlayer_GetFavoriteBadge_Response {
            has_favorite_badge: ::std::option::Option::None,
            badgeid: ::std::option::Option::None,
            communityitemid: ::std::option::Option::None,
            item_type: ::std::option::Option::None,
            border_color: ::std::option::Option::None,
            appid: ::std::option::Option::None,
            level: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_SetFavoriteBadge_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_SetFavoriteBadge_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_SetFavoriteBadge_Request.communityitemid)
    pub communityitemid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CPlayer_SetFavoriteBadge_Request.badgeid)
    pub badgeid: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_SetFavoriteBadge_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_SetFavoriteBadge_Request {
    fn default() -> &'a CPlayer_SetFavoriteBadge_Request {
        <CPlayer_SetFavoriteBadge_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_SetFavoriteBadge_Request {
    pub fn new() -> CPlayer_SetFavoriteBadge_Request {
        ::std::default::Default::default()
    }

    // optional uint64 communityitemid = 1;

    pub fn communityitemid(&self) -> u64 {
        self.communityitemid.unwrap_or(0)
    }

    pub fn clear_communityitemid(&mut self) {
        self.communityitemid = ::std::option::Option::None;
    }

    pub fn has_communityitemid(&self) -> bool {
        self.communityitemid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_communityitemid(&mut self, v: u64) {
        self.communityitemid = ::std::option::Option::Some(v);
    }

    // optional uint32 badgeid = 2;

    pub fn badgeid(&self) -> u32 {
        self.badgeid.unwrap_or(0)
    }

    pub fn clear_badgeid(&mut self) {
        self.badgeid = ::std::option::Option::None;
    }

    pub fn has_badgeid(&self) -> bool {
        self.badgeid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_badgeid(&mut self, v: u32) {
        self.badgeid = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetFavoriteBadge_Request {
    const NAME: &'static str = "CPlayer_SetFavoriteBadge_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.communityitemid = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.badgeid = ::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.communityitemid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.badgeid {
            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.communityitemid {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.badgeid {
            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() -> CPlayer_SetFavoriteBadge_Request {
        CPlayer_SetFavoriteBadge_Request::new()
    }

    fn clear(&mut self) {
        self.communityitemid = ::std::option::Option::None;
        self.badgeid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_SetFavoriteBadge_Request {
        static instance: CPlayer_SetFavoriteBadge_Request = CPlayer_SetFavoriteBadge_Request {
            communityitemid: ::std::option::Option::None,
            badgeid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_SetFavoriteBadge_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_SetFavoriteBadge_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_SetFavoriteBadge_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_SetFavoriteBadge_Response {
    fn default() -> &'a CPlayer_SetFavoriteBadge_Response {
        <CPlayer_SetFavoriteBadge_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_SetFavoriteBadge_Response {
    pub fn new() -> CPlayer_SetFavoriteBadge_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetFavoriteBadge_Response {
    const NAME: &'static str = "CPlayer_SetFavoriteBadge_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() -> CPlayer_SetFavoriteBadge_Response {
        CPlayer_SetFavoriteBadge_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_SetFavoriteBadge_Response {
        static instance: CPlayer_SetFavoriteBadge_Response = CPlayer_SetFavoriteBadge_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetProfileCustomization_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetProfileCustomization_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetProfileCustomization_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileCustomization_Request.include_inactive_customizations)
    pub include_inactive_customizations: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileCustomization_Request.include_purchased_customizations)
    pub include_purchased_customizations: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetProfileCustomization_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetProfileCustomization_Request {
    fn default() -> &'a CPlayer_GetProfileCustomization_Request {
        <CPlayer_GetProfileCustomization_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetProfileCustomization_Request {
    pub fn new() -> CPlayer_GetProfileCustomization_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 bool include_inactive_customizations = 2;

    pub fn include_inactive_customizations(&self) -> bool {
        self.include_inactive_customizations.unwrap_or(false)
    }

    pub fn clear_include_inactive_customizations(&mut self) {
        self.include_inactive_customizations = ::std::option::Option::None;
    }

    pub fn has_include_inactive_customizations(&self) -> bool {
        self.include_inactive_customizations.is_some()
    }

    // Param is passed by value, moved
    pub fn set_include_inactive_customizations(&mut self, v: bool) {
        self.include_inactive_customizations = ::std::option::Option::Some(v);
    }

    // optional bool include_purchased_customizations = 3;

    pub fn include_purchased_customizations(&self) -> bool {
        self.include_purchased_customizations.unwrap_or(false)
    }

    pub fn clear_include_purchased_customizations(&mut self) {
        self.include_purchased_customizations = ::std::option::Option::None;
    }

    pub fn has_include_purchased_customizations(&self) -> bool {
        self.include_purchased_customizations.is_some()
    }

    // Param is passed by value, moved
    pub fn set_include_purchased_customizations(&mut self, v: bool) {
        self.include_purchased_customizations = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetProfileCustomization_Request {
    const NAME: &'static str = "CPlayer_GetProfileCustomization_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.include_inactive_customizations = ::std::option::Option::Some(is.read_bool()?);
                },
                24 => {
                    self.include_purchased_customizations = ::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.include_inactive_customizations {
            my_size += 1 + 1;
        }
        if let Some(v) = self.include_purchased_customizations {
            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.include_inactive_customizations {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.include_purchased_customizations {
            os.write_bool(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() -> CPlayer_GetProfileCustomization_Request {
        CPlayer_GetProfileCustomization_Request::new()
    }

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.include_inactive_customizations = ::std::option::Option::None;
        self.include_purchased_customizations = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetProfileCustomization_Request {
        static instance: CPlayer_GetProfileCustomization_Request = CPlayer_GetProfileCustomization_Request {
            steamid: ::std::option::Option::None,
            include_inactive_customizations: ::std::option::Option::None,
            include_purchased_customizations: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:ProfileCustomizationSlot)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ProfileCustomizationSlot {
    // message fields
    // @@protoc_insertion_point(field:ProfileCustomizationSlot.slot)
    pub slot: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:ProfileCustomizationSlot.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:ProfileCustomizationSlot.publishedfileid)
    pub publishedfileid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:ProfileCustomizationSlot.item_assetid)
    pub item_assetid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:ProfileCustomizationSlot.item_contextid)
    pub item_contextid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:ProfileCustomizationSlot.notes)
    pub notes: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:ProfileCustomizationSlot.title)
    pub title: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:ProfileCustomizationSlot.accountid)
    pub accountid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:ProfileCustomizationSlot.badgeid)
    pub badgeid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:ProfileCustomizationSlot.border_color)
    pub border_color: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:ProfileCustomizationSlot.item_classid)
    pub item_classid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:ProfileCustomizationSlot.item_instanceid)
    pub item_instanceid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:ProfileCustomizationSlot.ban_check_result)
    pub ban_check_result: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::steammessages_base::EBanContentCheckResult>>,
    // @@protoc_insertion_point(field:ProfileCustomizationSlot.replay_year)
    pub replay_year: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:ProfileCustomizationSlot.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a ProfileCustomizationSlot {
    fn default() -> &'a ProfileCustomizationSlot {
        <ProfileCustomizationSlot as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl ProfileCustomizationSlot {
    pub fn new() -> ProfileCustomizationSlot {
        ::std::default::Default::default()
    }

    // optional uint32 slot = 1;

    pub fn slot(&self) -> u32 {
        self.slot.unwrap_or(0)
    }

    pub fn clear_slot(&mut self) {
        self.slot = ::std::option::Option::None;
    }

    pub fn has_slot(&self) -> bool {
        self.slot.is_some()
    }

    // Param is passed by value, moved
    pub fn set_slot(&mut self, v: u32) {
        self.slot = ::std::option::Option::Some(v);
    }

    // optional uint32 appid = 2;

    pub fn appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }

    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

    pub fn has_appid(&self) -> bool {
        self.appid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_appid(&mut self, v: u32) {
        self.appid = ::std::option::Option::Some(v);
    }

    // optional uint64 publishedfileid = 3;

    pub fn publishedfileid(&self) -> u64 {
        self.publishedfileid.unwrap_or(0)
    }

    pub fn clear_publishedfileid(&mut self) {
        self.publishedfileid = ::std::option::Option::None;
    }

    pub fn has_publishedfileid(&self) -> bool {
        self.publishedfileid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_publishedfileid(&mut self, v: u64) {
        self.publishedfileid = ::std::option::Option::Some(v);
    }

    // optional uint64 item_assetid = 4;

    pub fn item_assetid(&self) -> u64 {
        self.item_assetid.unwrap_or(0)
    }

    pub fn clear_item_assetid(&mut self) {
        self.item_assetid = ::std::option::Option::None;
    }

    pub fn has_item_assetid(&self) -> bool {
        self.item_assetid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_item_assetid(&mut self, v: u64) {
        self.item_assetid = ::std::option::Option::Some(v);
    }

    // optional uint64 item_contextid = 5;

    pub fn item_contextid(&self) -> u64 {
        self.item_contextid.unwrap_or(0)
    }

    pub fn clear_item_contextid(&mut self) {
        self.item_contextid = ::std::option::Option::None;
    }

    pub fn has_item_contextid(&self) -> bool {
        self.item_contextid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_item_contextid(&mut self, v: u64) {
        self.item_contextid = ::std::option::Option::Some(v);
    }

    // optional string notes = 6;

    pub fn notes(&self) -> &str {
        match self.notes.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_notes(&mut self) {
        self.notes = ::std::option::Option::None;
    }

    pub fn has_notes(&self) -> bool {
        self.notes.is_some()
    }

    // Param is passed by value, moved
    pub fn set_notes(&mut self, v: ::std::string::String) {
        self.notes = ::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_notes(&mut self) -> &mut ::std::string::String {
        if self.notes.is_none() {
            self.notes = ::std::option::Option::Some(::std::string::String::new());
        }
        self.notes.as_mut().unwrap()
    }

    // Take field
    pub fn take_notes(&mut self) -> ::std::string::String {
        self.notes.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string title = 7;

    pub fn title(&self) -> &str {
        match self.title.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_title(&mut self) {
        self.title = ::std::option::Option::None;
    }

    pub fn has_title(&self) -> bool {
        self.title.is_some()
    }

    // Param is passed by value, moved
    pub fn set_title(&mut self, v: ::std::string::String) {
        self.title = ::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_title(&mut self) -> &mut ::std::string::String {
        if self.title.is_none() {
            self.title = ::std::option::Option::Some(::std::string::String::new());
        }
        self.title.as_mut().unwrap()
    }

    // Take field
    pub fn take_title(&mut self) -> ::std::string::String {
        self.title.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional uint32 accountid = 8;

    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 badgeid = 9;

    pub fn badgeid(&self) -> u32 {
        self.badgeid.unwrap_or(0)
    }

    pub fn clear_badgeid(&mut self) {
        self.badgeid = ::std::option::Option::None;
    }

    pub fn has_badgeid(&self) -> bool {
        self.badgeid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_badgeid(&mut self, v: u32) {
        self.badgeid = ::std::option::Option::Some(v);
    }

    // optional uint32 border_color = 10;

    pub fn border_color(&self) -> u32 {
        self.border_color.unwrap_or(0)
    }

    pub fn clear_border_color(&mut self) {
        self.border_color = ::std::option::Option::None;
    }

    pub fn has_border_color(&self) -> bool {
        self.border_color.is_some()
    }

    // Param is passed by value, moved
    pub fn set_border_color(&mut self, v: u32) {
        self.border_color = ::std::option::Option::Some(v);
    }

    // optional uint64 item_classid = 11;

    pub fn item_classid(&self) -> u64 {
        self.item_classid.unwrap_or(0)
    }

    pub fn clear_item_classid(&mut self) {
        self.item_classid = ::std::option::Option::None;
    }

    pub fn has_item_classid(&self) -> bool {
        self.item_classid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_item_classid(&mut self, v: u64) {
        self.item_classid = ::std::option::Option::Some(v);
    }

    // optional uint64 item_instanceid = 12;

    pub fn item_instanceid(&self) -> u64 {
        self.item_instanceid.unwrap_or(0)
    }

    pub fn clear_item_instanceid(&mut self) {
        self.item_instanceid = ::std::option::Option::None;
    }

    pub fn has_item_instanceid(&self) -> bool {
        self.item_instanceid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_item_instanceid(&mut self, v: u64) {
        self.item_instanceid = ::std::option::Option::Some(v);
    }

    // optional .EBanContentCheckResult ban_check_result = 13;

    pub fn ban_check_result(&self) -> super::steammessages_base::EBanContentCheckResult {
        match self.ban_check_result {
            Some(e) => e.enum_value_or(super::steammessages_base::EBanContentCheckResult::k_EBanContentCheckResult_NotScanned),
            None => super::steammessages_base::EBanContentCheckResult::k_EBanContentCheckResult_NotScanned,
        }
    }

    pub fn clear_ban_check_result(&mut self) {
        self.ban_check_result = ::std::option::Option::None;
    }

    pub fn has_ban_check_result(&self) -> bool {
        self.ban_check_result.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ban_check_result(&mut self, v: super::steammessages_base::EBanContentCheckResult) {
        self.ban_check_result = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional uint32 replay_year = 14;

    pub fn replay_year(&self) -> u32 {
        self.replay_year.unwrap_or(0)
    }

    pub fn clear_replay_year(&mut self) {
        self.replay_year = ::std::option::Option::None;
    }

    pub fn has_replay_year(&self) -> bool {
        self.replay_year.is_some()
    }

    // Param is passed by value, moved
    pub fn set_replay_year(&mut self, v: u32) {
        self.replay_year = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for ProfileCustomizationSlot {
    const NAME: &'static str = "ProfileCustomizationSlot";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.slot = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.publishedfileid = ::std::option::Option::Some(is.read_uint64()?);
                },
                32 => {
                    self.item_assetid = ::std::option::Option::Some(is.read_uint64()?);
                },
                40 => {
                    self.item_contextid = ::std::option::Option::Some(is.read_uint64()?);
                },
                50 => {
                    self.notes = ::std::option::Option::Some(is.read_string()?);
                },
                58 => {
                    self.title = ::std::option::Option::Some(is.read_string()?);
                },
                64 => {
                    self.accountid = ::std::option::Option::Some(is.read_uint32()?);
                },
                72 => {
                    self.badgeid = ::std::option::Option::Some(is.read_uint32()?);
                },
                80 => {
                    self.border_color = ::std::option::Option::Some(is.read_uint32()?);
                },
                88 => {
                    self.item_classid = ::std::option::Option::Some(is.read_uint64()?);
                },
                96 => {
                    self.item_instanceid = ::std::option::Option::Some(is.read_uint64()?);
                },
                104 => {
                    self.ban_check_result = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                112 => {
                    self.replay_year = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.slot {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.publishedfileid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
        }
        if let Some(v) = self.item_assetid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(4, v);
        }
        if let Some(v) = self.item_contextid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(5, v);
        }
        if let Some(v) = self.notes.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.title.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
        }
        if let Some(v) = self.accountid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, v);
        }
        if let Some(v) = self.badgeid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
        }
        if let Some(v) = self.border_color {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(10, v);
        }
        if let Some(v) = self.item_classid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(11, v);
        }
        if let Some(v) = self.item_instanceid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(12, v);
        }
        if let Some(v) = self.ban_check_result {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(13, v.value());
        }
        if let Some(v) = self.replay_year {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(14, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.slot {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.publishedfileid {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.item_assetid {
            os.write_uint64(4, v)?;
        }
        if let Some(v) = self.item_contextid {
            os.write_uint64(5, v)?;
        }
        if let Some(v) = self.notes.as_ref() {
            os.write_string(6, v)?;
        }
        if let Some(v) = self.title.as_ref() {
            os.write_string(7, v)?;
        }
        if let Some(v) = self.accountid {
            os.write_uint32(8, v)?;
        }
        if let Some(v) = self.badgeid {
            os.write_uint32(9, v)?;
        }
        if let Some(v) = self.border_color {
            os.write_uint32(10, v)?;
        }
        if let Some(v) = self.item_classid {
            os.write_uint64(11, v)?;
        }
        if let Some(v) = self.item_instanceid {
            os.write_uint64(12, v)?;
        }
        if let Some(v) = self.ban_check_result {
            os.write_enum(13, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.replay_year {
            os.write_uint32(14, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> ProfileCustomizationSlot {
        ProfileCustomizationSlot::new()
    }

    fn clear(&mut self) {
        self.slot = ::std::option::Option::None;
        self.appid = ::std::option::Option::None;
        self.publishedfileid = ::std::option::Option::None;
        self.item_assetid = ::std::option::Option::None;
        self.item_contextid = ::std::option::Option::None;
        self.notes = ::std::option::Option::None;
        self.title = ::std::option::Option::None;
        self.accountid = ::std::option::Option::None;
        self.badgeid = ::std::option::Option::None;
        self.border_color = ::std::option::Option::None;
        self.item_classid = ::std::option::Option::None;
        self.item_instanceid = ::std::option::Option::None;
        self.ban_check_result = ::std::option::Option::None;
        self.replay_year = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ProfileCustomizationSlot {
        static instance: ProfileCustomizationSlot = ProfileCustomizationSlot {
            slot: ::std::option::Option::None,
            appid: ::std::option::Option::None,
            publishedfileid: ::std::option::Option::None,
            item_assetid: ::std::option::Option::None,
            item_contextid: ::std::option::Option::None,
            notes: ::std::option::Option::None,
            title: ::std::option::Option::None,
            accountid: ::std::option::Option::None,
            badgeid: ::std::option::Option::None,
            border_color: ::std::option::Option::None,
            item_classid: ::std::option::Option::None,
            item_instanceid: ::std::option::Option::None,
            ban_check_result: ::std::option::Option::None,
            replay_year: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:ProfileCustomization)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ProfileCustomization {
    // message fields
    // @@protoc_insertion_point(field:ProfileCustomization.customization_type)
    pub customization_type: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::enums::EProfileCustomizationType>>,
    // @@protoc_insertion_point(field:ProfileCustomization.large)
    pub large: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:ProfileCustomization.slots)
    pub slots: ::std::vec::Vec<ProfileCustomizationSlot>,
    // @@protoc_insertion_point(field:ProfileCustomization.active)
    pub active: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:ProfileCustomization.customization_style)
    pub customization_style: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<EProfileCustomizationStyle>>,
    // @@protoc_insertion_point(field:ProfileCustomization.purchaseid)
    pub purchaseid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:ProfileCustomization.level)
    pub level: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:ProfileCustomization.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a ProfileCustomization {
    fn default() -> &'a ProfileCustomization {
        <ProfileCustomization as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl ProfileCustomization {
    pub fn new() -> ProfileCustomization {
        ::std::default::Default::default()
    }

    // optional .EProfileCustomizationType customization_type = 1;

    pub fn customization_type(&self) -> super::enums::EProfileCustomizationType {
        match self.customization_type {
            Some(e) => e.enum_value_or(super::enums::EProfileCustomizationType::k_EProfileCustomizationTypeInvalid),
            None => super::enums::EProfileCustomizationType::k_EProfileCustomizationTypeInvalid,
        }
    }

    pub fn clear_customization_type(&mut self) {
        self.customization_type = ::std::option::Option::None;
    }

    pub fn has_customization_type(&self) -> bool {
        self.customization_type.is_some()
    }

    // Param is passed by value, moved
    pub fn set_customization_type(&mut self, v: super::enums::EProfileCustomizationType) {
        self.customization_type = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional bool large = 2;

    pub fn large(&self) -> bool {
        self.large.unwrap_or(false)
    }

    pub fn clear_large(&mut self) {
        self.large = ::std::option::Option::None;
    }

    pub fn has_large(&self) -> bool {
        self.large.is_some()
    }

    // Param is passed by value, moved
    pub fn set_large(&mut self, v: bool) {
        self.large = ::std::option::Option::Some(v);
    }

    // optional bool active = 4;

    pub fn active(&self) -> bool {
        self.active.unwrap_or(false)
    }

    pub fn clear_active(&mut self) {
        self.active = ::std::option::Option::None;
    }

    pub fn has_active(&self) -> bool {
        self.active.is_some()
    }

    // Param is passed by value, moved
    pub fn set_active(&mut self, v: bool) {
        self.active = ::std::option::Option::Some(v);
    }

    // optional .EProfileCustomizationStyle customization_style = 5;

    pub fn customization_style(&self) -> EProfileCustomizationStyle {
        match self.customization_style {
            Some(e) => e.enum_value_or(EProfileCustomizationStyle::k_EProfileCustomizationStyleDefault),
            None => EProfileCustomizationStyle::k_EProfileCustomizationStyleDefault,
        }
    }

    pub fn clear_customization_style(&mut self) {
        self.customization_style = ::std::option::Option::None;
    }

    pub fn has_customization_style(&self) -> bool {
        self.customization_style.is_some()
    }

    // Param is passed by value, moved
    pub fn set_customization_style(&mut self, v: EProfileCustomizationStyle) {
        self.customization_style = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional uint64 purchaseid = 6;

    pub fn purchaseid(&self) -> u64 {
        self.purchaseid.unwrap_or(0)
    }

    pub fn clear_purchaseid(&mut self) {
        self.purchaseid = ::std::option::Option::None;
    }

    pub fn has_purchaseid(&self) -> bool {
        self.purchaseid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_purchaseid(&mut self, v: u64) {
        self.purchaseid = ::std::option::Option::Some(v);
    }

    // optional uint32 level = 7;

    pub fn level(&self) -> u32 {
        self.level.unwrap_or(0)
    }

    pub fn clear_level(&mut self) {
        self.level = ::std::option::Option::None;
    }

    pub fn has_level(&self) -> bool {
        self.level.is_some()
    }

    // Param is passed by value, moved
    pub fn set_level(&mut self, v: u32) {
        self.level = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for ProfileCustomization {
    const NAME: &'static str = "ProfileCustomization";

    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.customization_type = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                16 => {
                    self.large = ::std::option::Option::Some(is.read_bool()?);
                },
                26 => {
                    self.slots.push(is.read_message()?);
                },
                32 => {
                    self.active = ::std::option::Option::Some(is.read_bool()?);
                },
                40 => {
                    self.customization_style = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                48 => {
                    self.purchaseid = ::std::option::Option::Some(is.read_uint64()?);
                },
                56 => {
                    self.level = ::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.customization_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v.value());
        }
        if let Some(v) = self.large {
            my_size += 1 + 1;
        }
        for value in &self.slots {
            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.active {
            my_size += 1 + 1;
        }
        if let Some(v) = self.customization_style {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v.value());
        }
        if let Some(v) = self.purchaseid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(6, v);
        }
        if let Some(v) = self.level {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.customization_type {
            os.write_enum(1, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.large {
            os.write_bool(2, v)?;
        }
        for v in &self.slots {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        if let Some(v) = self.active {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.customization_style {
            os.write_enum(5, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.purchaseid {
            os.write_uint64(6, v)?;
        }
        if let Some(v) = self.level {
            os.write_uint32(7, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> ProfileCustomization {
        ProfileCustomization::new()
    }

    fn clear(&mut self) {
        self.customization_type = ::std::option::Option::None;
        self.large = ::std::option::Option::None;
        self.slots.clear();
        self.active = ::std::option::Option::None;
        self.customization_style = ::std::option::Option::None;
        self.purchaseid = ::std::option::Option::None;
        self.level = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ProfileCustomization {
        static instance: ProfileCustomization = ProfileCustomization {
            customization_type: ::std::option::Option::None,
            large: ::std::option::Option::None,
            slots: ::std::vec::Vec::new(),
            active: ::std::option::Option::None,
            customization_style: ::std::option::Option::None,
            purchaseid: ::std::option::Option::None,
            level: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:ProfileTheme)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ProfileTheme {
    // message fields
    // @@protoc_insertion_point(field:ProfileTheme.theme_id)
    pub theme_id: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:ProfileTheme.title)
    pub title: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:ProfileTheme.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a ProfileTheme {
    fn default() -> &'a ProfileTheme {
        <ProfileTheme as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl ProfileTheme {
    pub fn new() -> ProfileTheme {
        ::std::default::Default::default()
    }

    // optional string theme_id = 1;

    pub fn theme_id(&self) -> &str {
        match self.theme_id.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_theme_id(&mut self) {
        self.theme_id = ::std::option::Option::None;
    }

    pub fn has_theme_id(&self) -> bool {
        self.theme_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_theme_id(&mut self, v: ::std::string::String) {
        self.theme_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_theme_id(&mut self) -> &mut ::std::string::String {
        if self.theme_id.is_none() {
            self.theme_id = ::std::option::Option::Some(::std::string::String::new());
        }
        self.theme_id.as_mut().unwrap()
    }

    // Take field
    pub fn take_theme_id(&mut self) -> ::std::string::String {
        self.theme_id.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string title = 2;

    pub fn title(&self) -> &str {
        match self.title.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_title(&mut self) {
        self.title = ::std::option::Option::None;
    }

    pub fn has_title(&self) -> bool {
        self.title.is_some()
    }

    // Param is passed by value, moved
    pub fn set_title(&mut self, v: ::std::string::String) {
        self.title = ::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_title(&mut self) -> &mut ::std::string::String {
        if self.title.is_none() {
            self.title = ::std::option::Option::Some(::std::string::String::new());
        }
        self.title.as_mut().unwrap()
    }

    // Take field
    pub fn take_title(&mut self) -> ::std::string::String {
        self.title.take().unwrap_or_else(|| ::std::string::String::new())
    }
}

impl ::steam_vent_proto_common::protobuf::Message for ProfileTheme {
    const NAME: &'static str = "ProfileTheme";

    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.theme_id = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.title = ::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.theme_id.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.title.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.theme_id.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.title.as_ref() {
            os.write_string(2, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> ProfileTheme {
        ProfileTheme::new()
    }

    fn clear(&mut self) {
        self.theme_id = ::std::option::Option::None;
        self.title = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ProfileTheme {
        static instance: ProfileTheme = ProfileTheme {
            theme_id: ::std::option::Option::None,
            title: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:ProfilePreferences)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ProfilePreferences {
    // message fields
    // @@protoc_insertion_point(field:ProfilePreferences.hide_profile_awards)
    pub hide_profile_awards: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:ProfilePreferences.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a ProfilePreferences {
    fn default() -> &'a ProfilePreferences {
        <ProfilePreferences as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl ProfilePreferences {
    pub fn new() -> ProfilePreferences {
        ::std::default::Default::default()
    }

    // optional bool hide_profile_awards = 1;

    pub fn hide_profile_awards(&self) -> bool {
        self.hide_profile_awards.unwrap_or(false)
    }

    pub fn clear_hide_profile_awards(&mut self) {
        self.hide_profile_awards = ::std::option::Option::None;
    }

    pub fn has_hide_profile_awards(&self) -> bool {
        self.hide_profile_awards.is_some()
    }

    // Param is passed by value, moved
    pub fn set_hide_profile_awards(&mut self, v: bool) {
        self.hide_profile_awards = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for ProfilePreferences {
    const NAME: &'static str = "ProfilePreferences";

    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.hide_profile_awards = ::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.hide_profile_awards {
            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.hide_profile_awards {
            os.write_bool(1, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> ProfilePreferences {
        ProfilePreferences::new()
    }

    fn clear(&mut self) {
        self.hide_profile_awards = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ProfilePreferences {
        static instance: ProfilePreferences = ProfilePreferences {
            hide_profile_awards: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetProfileCustomization_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetProfileCustomization_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetProfileCustomization_Response.customizations)
    pub customizations: ::std::vec::Vec<ProfileCustomization>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileCustomization_Response.slots_available)
    pub slots_available: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileCustomization_Response.profile_theme)
    pub profile_theme: ::steam_vent_proto_common::protobuf::MessageField<ProfileTheme>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileCustomization_Response.purchased_customizations)
    pub purchased_customizations: ::std::vec::Vec<cplayer_get_profile_customization_response::PurchasedCustomization>,
    // @@protoc_insertion_point(field:CPlayer_GetProfileCustomization_Response.profile_preferences)
    pub profile_preferences: ::steam_vent_proto_common::protobuf::MessageField<ProfilePreferences>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetProfileCustomization_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetProfileCustomization_Response {
    fn default() -> &'a CPlayer_GetProfileCustomization_Response {
        <CPlayer_GetProfileCustomization_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetProfileCustomization_Response {
    pub fn new() -> CPlayer_GetProfileCustomization_Response {
        ::std::default::Default::default()
    }

    // optional uint32 slots_available = 2;

    pub fn slots_available(&self) -> u32 {
        self.slots_available.unwrap_or(0)
    }

    pub fn clear_slots_available(&mut self) {
        self.slots_available = ::std::option::Option::None;
    }

    pub fn has_slots_available(&self) -> bool {
        self.slots_available.is_some()
    }

    // Param is passed by value, moved
    pub fn set_slots_available(&mut self, v: u32) {
        self.slots_available = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetProfileCustomization_Response {
    const NAME: &'static str = "CPlayer_GetProfileCustomization_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.customizations.push(is.read_message()?);
                },
                16 => {
                    self.slots_available = ::std::option::Option::Some(is.read_uint32()?);
                },
                26 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.profile_theme)?;
                },
                34 => {
                    self.purchased_customizations.push(is.read_message()?);
                },
                42 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.profile_preferences)?;
                },
                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.customizations {
            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.slots_available {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.profile_theme.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.purchased_customizations {
            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.profile_preferences.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.customizations {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        if let Some(v) = self.slots_available {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.profile_theme.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        for v in &self.purchased_customizations {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        if let Some(v) = self.profile_preferences.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetProfileCustomization_Response {
        CPlayer_GetProfileCustomization_Response::new()
    }

    fn clear(&mut self) {
        self.customizations.clear();
        self.slots_available = ::std::option::Option::None;
        self.profile_theme.clear();
        self.purchased_customizations.clear();
        self.profile_preferences.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetProfileCustomization_Response {
        static instance: CPlayer_GetProfileCustomization_Response = CPlayer_GetProfileCustomization_Response {
            customizations: ::std::vec::Vec::new(),
            slots_available: ::std::option::Option::None,
            profile_theme: ::steam_vent_proto_common::protobuf::MessageField::none(),
            purchased_customizations: ::std::vec::Vec::new(),
            profile_preferences: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CPlayer_GetProfileCustomization_Response`
pub mod cplayer_get_profile_customization_response {
    // @@protoc_insertion_point(message:CPlayer_GetProfileCustomization_Response.PurchasedCustomization)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct PurchasedCustomization {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetProfileCustomization_Response.PurchasedCustomization.purchaseid)
        pub purchaseid: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CPlayer_GetProfileCustomization_Response.PurchasedCustomization.customization_type)
        pub customization_type: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::super::enums::EProfileCustomizationType>>,
        // @@protoc_insertion_point(field:CPlayer_GetProfileCustomization_Response.PurchasedCustomization.level)
        pub level: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetProfileCustomization_Response.PurchasedCustomization.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

    impl<'a> ::std::default::Default for &'a PurchasedCustomization {
        fn default() -> &'a PurchasedCustomization {
            <PurchasedCustomization as ::steam_vent_proto_common::protobuf::Message>::default_instance()
        }
    }

    impl PurchasedCustomization {
        pub fn new() -> PurchasedCustomization {
            ::std::default::Default::default()
        }

        // optional uint64 purchaseid = 1;

        pub fn purchaseid(&self) -> u64 {
            self.purchaseid.unwrap_or(0)
        }

        pub fn clear_purchaseid(&mut self) {
            self.purchaseid = ::std::option::Option::None;
        }

        pub fn has_purchaseid(&self) -> bool {
            self.purchaseid.is_some()
        }

        // Param is passed by value, moved
        pub fn set_purchaseid(&mut self, v: u64) {
            self.purchaseid = ::std::option::Option::Some(v);
        }

        // optional .EProfileCustomizationType customization_type = 2;

        pub fn customization_type(&self) -> super::super::enums::EProfileCustomizationType {
            match self.customization_type {
                Some(e) => e.enum_value_or(super::super::enums::EProfileCustomizationType::k_EProfileCustomizationTypeInvalid),
                None => super::super::enums::EProfileCustomizationType::k_EProfileCustomizationTypeInvalid,
            }
        }

        pub fn clear_customization_type(&mut self) {
            self.customization_type = ::std::option::Option::None;
        }

        pub fn has_customization_type(&self) -> bool {
            self.customization_type.is_some()
        }

        // Param is passed by value, moved
        pub fn set_customization_type(&mut self, v: super::super::enums::EProfileCustomizationType) {
            self.customization_type = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
        }

        // optional uint32 level = 3;

        pub fn level(&self) -> u32 {
            self.level.unwrap_or(0)
        }

        pub fn clear_level(&mut self) {
            self.level = ::std::option::Option::None;
        }

        pub fn has_level(&self) -> bool {
            self.level.is_some()
        }

        // Param is passed by value, moved
        pub fn set_level(&mut self, v: u32) {
            self.level = ::std::option::Option::Some(v);
        }
    }

    impl ::steam_vent_proto_common::protobuf::Message for PurchasedCustomization {
        const NAME: &'static str = "PurchasedCustomization";

        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.purchaseid = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    16 => {
                        self.customization_type = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                    },
                    24 => {
                        self.level = ::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.purchaseid {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
            }
            if let Some(v) = self.customization_type {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v.value());
            }
            if let Some(v) = self.level {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.purchaseid {
                os.write_uint64(1, v)?;
            }
            if let Some(v) = self.customization_type {
                os.write_enum(2, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
            }
            if let Some(v) = self.level {
                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() -> PurchasedCustomization {
            PurchasedCustomization::new()
        }

        fn clear(&mut self) {
            self.purchaseid = ::std::option::Option::None;
            self.customization_type = ::std::option::Option::None;
            self.level = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static PurchasedCustomization {
            static instance: PurchasedCustomization = PurchasedCustomization {
                purchaseid: ::std::option::Option::None,
                customization_type: ::std::option::Option::None,
                level: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CPlayer_GetPurchasedProfileCustomizations_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetPurchasedProfileCustomizations_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetPurchasedProfileCustomizations_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetPurchasedProfileCustomizations_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetPurchasedProfileCustomizations_Request {
    fn default() -> &'a CPlayer_GetPurchasedProfileCustomizations_Request {
        <CPlayer_GetPurchasedProfileCustomizations_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetPurchasedProfileCustomizations_Request {
    pub fn new() -> CPlayer_GetPurchasedProfileCustomizations_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 CPlayer_GetPurchasedProfileCustomizations_Request {
    const NAME: &'static str = "CPlayer_GetPurchasedProfileCustomizations_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() -> CPlayer_GetPurchasedProfileCustomizations_Request {
        CPlayer_GetPurchasedProfileCustomizations_Request::new()
    }

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetPurchasedProfileCustomizations_Request {
        static instance: CPlayer_GetPurchasedProfileCustomizations_Request = CPlayer_GetPurchasedProfileCustomizations_Request {
            steamid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetPurchasedProfileCustomizations_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetPurchasedProfileCustomizations_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetPurchasedProfileCustomizations_Response.purchased_customizations)
    pub purchased_customizations: ::std::vec::Vec<cplayer_get_purchased_profile_customizations_response::PurchasedCustomization>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetPurchasedProfileCustomizations_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetPurchasedProfileCustomizations_Response {
    fn default() -> &'a CPlayer_GetPurchasedProfileCustomizations_Response {
        <CPlayer_GetPurchasedProfileCustomizations_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetPurchasedProfileCustomizations_Response {
    pub fn new() -> CPlayer_GetPurchasedProfileCustomizations_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetPurchasedProfileCustomizations_Response {
    const NAME: &'static str = "CPlayer_GetPurchasedProfileCustomizations_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.purchased_customizations.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.purchased_customizations {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.purchased_customizations {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetPurchasedProfileCustomizations_Response {
        CPlayer_GetPurchasedProfileCustomizations_Response::new()
    }

    fn clear(&mut self) {
        self.purchased_customizations.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetPurchasedProfileCustomizations_Response {
        static instance: CPlayer_GetPurchasedProfileCustomizations_Response = CPlayer_GetPurchasedProfileCustomizations_Response {
            purchased_customizations: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CPlayer_GetPurchasedProfileCustomizations_Response`
pub mod cplayer_get_purchased_profile_customizations_response {
    // @@protoc_insertion_point(message:CPlayer_GetPurchasedProfileCustomizations_Response.PurchasedCustomization)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct PurchasedCustomization {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetPurchasedProfileCustomizations_Response.PurchasedCustomization.purchaseid)
        pub purchaseid: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CPlayer_GetPurchasedProfileCustomizations_Response.PurchasedCustomization.customization_type)
        pub customization_type: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::super::enums::EProfileCustomizationType>>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetPurchasedProfileCustomizations_Response.PurchasedCustomization.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

    impl<'a> ::std::default::Default for &'a PurchasedCustomization {
        fn default() -> &'a PurchasedCustomization {
            <PurchasedCustomization as ::steam_vent_proto_common::protobuf::Message>::default_instance()
        }
    }

    impl PurchasedCustomization {
        pub fn new() -> PurchasedCustomization {
            ::std::default::Default::default()
        }

        // optional uint64 purchaseid = 1;

        pub fn purchaseid(&self) -> u64 {
            self.purchaseid.unwrap_or(0)
        }

        pub fn clear_purchaseid(&mut self) {
            self.purchaseid = ::std::option::Option::None;
        }

        pub fn has_purchaseid(&self) -> bool {
            self.purchaseid.is_some()
        }

        // Param is passed by value, moved
        pub fn set_purchaseid(&mut self, v: u64) {
            self.purchaseid = ::std::option::Option::Some(v);
        }

        // optional .EProfileCustomizationType customization_type = 2;

        pub fn customization_type(&self) -> super::super::enums::EProfileCustomizationType {
            match self.customization_type {
                Some(e) => e.enum_value_or(super::super::enums::EProfileCustomizationType::k_EProfileCustomizationTypeInvalid),
                None => super::super::enums::EProfileCustomizationType::k_EProfileCustomizationTypeInvalid,
            }
        }

        pub fn clear_customization_type(&mut self) {
            self.customization_type = ::std::option::Option::None;
        }

        pub fn has_customization_type(&self) -> bool {
            self.customization_type.is_some()
        }

        // Param is passed by value, moved
        pub fn set_customization_type(&mut self, v: super::super::enums::EProfileCustomizationType) {
            self.customization_type = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
        }
    }

    impl ::steam_vent_proto_common::protobuf::Message for PurchasedCustomization {
        const NAME: &'static str = "PurchasedCustomization";

        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.purchaseid = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    16 => {
                        self.customization_type = ::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.purchaseid {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
            }
            if let Some(v) = self.customization_type {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, 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.purchaseid {
                os.write_uint64(1, v)?;
            }
            if let Some(v) = self.customization_type {
                os.write_enum(2, ::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() -> PurchasedCustomization {
            PurchasedCustomization::new()
        }

        fn clear(&mut self) {
            self.purchaseid = ::std::option::Option::None;
            self.customization_type = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static PurchasedCustomization {
            static instance: PurchasedCustomization = PurchasedCustomization {
                purchaseid: ::std::option::Option::None,
                customization_type: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Request {
    fn default() -> &'a CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Request {
        <CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Request {
    pub fn new() -> CPlayer_GetPurchasedAndUpgradedProfileCustomizations_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 CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Request {
    const NAME: &'static str = "CPlayer_GetPurchasedAndUpgradedProfileCustomizations_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() -> CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Request {
        CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Request::new()
    }

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Request {
        static instance: CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Request = CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Request {
            steamid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response.purchased_customizations)
    pub purchased_customizations: ::std::vec::Vec<cplayer_get_purchased_and_upgraded_profile_customizations_response::PurchasedCustomization>,
    // @@protoc_insertion_point(field:CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response.upgraded_customizations)
    pub upgraded_customizations: ::std::vec::Vec<cplayer_get_purchased_and_upgraded_profile_customizations_response::UpgradedCustomization>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response {
    fn default() -> &'a CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response {
        <CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response {
    pub fn new() -> CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response {
    const NAME: &'static str = "CPlayer_GetPurchasedAndUpgradedProfileCustomizations_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.purchased_customizations.push(is.read_message()?);
                },
                18 => {
                    self.upgraded_customizations.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.purchased_customizations {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.upgraded_customizations {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.purchased_customizations {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        for v in &self.upgraded_customizations {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response {
        CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response::new()
    }

    fn clear(&mut self) {
        self.purchased_customizations.clear();
        self.upgraded_customizations.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response {
        static instance: CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response = CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response {
            purchased_customizations: ::std::vec::Vec::new(),
            upgraded_customizations: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response`
pub mod cplayer_get_purchased_and_upgraded_profile_customizations_response {
    // @@protoc_insertion_point(message:CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response.PurchasedCustomization)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct PurchasedCustomization {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response.PurchasedCustomization.customization_type)
        pub customization_type: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::super::enums::EProfileCustomizationType>>,
        // @@protoc_insertion_point(field:CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response.PurchasedCustomization.count)
        pub count: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response.PurchasedCustomization.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

    impl<'a> ::std::default::Default for &'a PurchasedCustomization {
        fn default() -> &'a PurchasedCustomization {
            <PurchasedCustomization as ::steam_vent_proto_common::protobuf::Message>::default_instance()
        }
    }

    impl PurchasedCustomization {
        pub fn new() -> PurchasedCustomization {
            ::std::default::Default::default()
        }

        // optional .EProfileCustomizationType customization_type = 1;

        pub fn customization_type(&self) -> super::super::enums::EProfileCustomizationType {
            match self.customization_type {
                Some(e) => e.enum_value_or(super::super::enums::EProfileCustomizationType::k_EProfileCustomizationTypeInvalid),
                None => super::super::enums::EProfileCustomizationType::k_EProfileCustomizationTypeInvalid,
            }
        }

        pub fn clear_customization_type(&mut self) {
            self.customization_type = ::std::option::Option::None;
        }

        pub fn has_customization_type(&self) -> bool {
            self.customization_type.is_some()
        }

        // Param is passed by value, moved
        pub fn set_customization_type(&mut self, v: super::super::enums::EProfileCustomizationType) {
            self.customization_type = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
        }

        // optional uint32 count = 2;

        pub fn count(&self) -> u32 {
            self.count.unwrap_or(0)
        }

        pub fn clear_count(&mut self) {
            self.count = ::std::option::Option::None;
        }

        pub fn has_count(&self) -> bool {
            self.count.is_some()
        }

        // Param is passed by value, moved
        pub fn set_count(&mut self, v: u32) {
            self.count = ::std::option::Option::Some(v);
        }
    }

    impl ::steam_vent_proto_common::protobuf::Message for PurchasedCustomization {
        const NAME: &'static str = "PurchasedCustomization";

        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.customization_type = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                    },
                    16 => {
                        self.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.customization_type {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v.value());
            }
            if let Some(v) = self.count {
                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.customization_type {
                os.write_enum(1, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
            }
            if let Some(v) = self.count {
                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() -> PurchasedCustomization {
            PurchasedCustomization::new()
        }

        fn clear(&mut self) {
            self.customization_type = ::std::option::Option::None;
            self.count = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static PurchasedCustomization {
            static instance: PurchasedCustomization = PurchasedCustomization {
                customization_type: ::std::option::Option::None,
                count: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response.UpgradedCustomization)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct UpgradedCustomization {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response.UpgradedCustomization.customization_type)
        pub customization_type: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::super::enums::EProfileCustomizationType>>,
        // @@protoc_insertion_point(field:CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response.UpgradedCustomization.level)
        pub level: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response.UpgradedCustomization.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

    impl<'a> ::std::default::Default for &'a UpgradedCustomization {
        fn default() -> &'a UpgradedCustomization {
            <UpgradedCustomization as ::steam_vent_proto_common::protobuf::Message>::default_instance()
        }
    }

    impl UpgradedCustomization {
        pub fn new() -> UpgradedCustomization {
            ::std::default::Default::default()
        }

        // optional .EProfileCustomizationType customization_type = 1;

        pub fn customization_type(&self) -> super::super::enums::EProfileCustomizationType {
            match self.customization_type {
                Some(e) => e.enum_value_or(super::super::enums::EProfileCustomizationType::k_EProfileCustomizationTypeInvalid),
                None => super::super::enums::EProfileCustomizationType::k_EProfileCustomizationTypeInvalid,
            }
        }

        pub fn clear_customization_type(&mut self) {
            self.customization_type = ::std::option::Option::None;
        }

        pub fn has_customization_type(&self) -> bool {
            self.customization_type.is_some()
        }

        // Param is passed by value, moved
        pub fn set_customization_type(&mut self, v: super::super::enums::EProfileCustomizationType) {
            self.customization_type = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
        }

        // optional uint32 level = 2;

        pub fn level(&self) -> u32 {
            self.level.unwrap_or(0)
        }

        pub fn clear_level(&mut self) {
            self.level = ::std::option::Option::None;
        }

        pub fn has_level(&self) -> bool {
            self.level.is_some()
        }

        // Param is passed by value, moved
        pub fn set_level(&mut self, v: u32) {
            self.level = ::std::option::Option::Some(v);
        }
    }

    impl ::steam_vent_proto_common::protobuf::Message for UpgradedCustomization {
        const NAME: &'static str = "UpgradedCustomization";

        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.customization_type = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                    },
                    16 => {
                        self.level = ::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.customization_type {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v.value());
            }
            if let Some(v) = self.level {
                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.customization_type {
                os.write_enum(1, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
            }
            if let Some(v) = self.level {
                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() -> UpgradedCustomization {
            UpgradedCustomization::new()
        }

        fn clear(&mut self) {
            self.customization_type = ::std::option::Option::None;
            self.level = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static UpgradedCustomization {
            static instance: UpgradedCustomization = UpgradedCustomization {
                customization_type: ::std::option::Option::None,
                level: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CPlayer_GetProfileThemesAvailable_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetProfileThemesAvailable_Request {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetProfileThemesAvailable_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetProfileThemesAvailable_Request {
    fn default() -> &'a CPlayer_GetProfileThemesAvailable_Request {
        <CPlayer_GetProfileThemesAvailable_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetProfileThemesAvailable_Request {
    pub fn new() -> CPlayer_GetProfileThemesAvailable_Request {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetProfileThemesAvailable_Request {
    const NAME: &'static str = "CPlayer_GetProfileThemesAvailable_Request";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetProfileThemesAvailable_Request {
        CPlayer_GetProfileThemesAvailable_Request::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetProfileThemesAvailable_Request {
        static instance: CPlayer_GetProfileThemesAvailable_Request = CPlayer_GetProfileThemesAvailable_Request {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetProfileThemesAvailable_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetProfileThemesAvailable_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetProfileThemesAvailable_Response.profile_themes)
    pub profile_themes: ::std::vec::Vec<ProfileTheme>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetProfileThemesAvailable_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetProfileThemesAvailable_Response {
    fn default() -> &'a CPlayer_GetProfileThemesAvailable_Response {
        <CPlayer_GetProfileThemesAvailable_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetProfileThemesAvailable_Response {
    pub fn new() -> CPlayer_GetProfileThemesAvailable_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetProfileThemesAvailable_Response {
    const NAME: &'static str = "CPlayer_GetProfileThemesAvailable_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.profile_themes.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.profile_themes {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.profile_themes {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetProfileThemesAvailable_Response {
        CPlayer_GetProfileThemesAvailable_Response::new()
    }

    fn clear(&mut self) {
        self.profile_themes.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetProfileThemesAvailable_Response {
        static instance: CPlayer_GetProfileThemesAvailable_Response = CPlayer_GetProfileThemesAvailable_Response {
            profile_themes: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_SetProfileTheme_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_SetProfileTheme_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_SetProfileTheme_Request.theme_id)
    pub theme_id: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_SetProfileTheme_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_SetProfileTheme_Request {
    fn default() -> &'a CPlayer_SetProfileTheme_Request {
        <CPlayer_SetProfileTheme_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_SetProfileTheme_Request {
    pub fn new() -> CPlayer_SetProfileTheme_Request {
        ::std::default::Default::default()
    }

    // optional string theme_id = 1;

    pub fn theme_id(&self) -> &str {
        match self.theme_id.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_theme_id(&mut self) {
        self.theme_id = ::std::option::Option::None;
    }

    pub fn has_theme_id(&self) -> bool {
        self.theme_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_theme_id(&mut self, v: ::std::string::String) {
        self.theme_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_theme_id(&mut self) -> &mut ::std::string::String {
        if self.theme_id.is_none() {
            self.theme_id = ::std::option::Option::Some(::std::string::String::new());
        }
        self.theme_id.as_mut().unwrap()
    }

    // Take field
    pub fn take_theme_id(&mut self) -> ::std::string::String {
        self.theme_id.take().unwrap_or_else(|| ::std::string::String::new())
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetProfileTheme_Request {
    const NAME: &'static str = "CPlayer_SetProfileTheme_Request";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.theme_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.theme_id.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.theme_id.as_ref() {
            os.write_string(1, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_SetProfileTheme_Request {
        CPlayer_SetProfileTheme_Request::new()
    }

    fn clear(&mut self) {
        self.theme_id = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_SetProfileTheme_Request {
        static instance: CPlayer_SetProfileTheme_Request = CPlayer_SetProfileTheme_Request {
            theme_id: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_SetProfileTheme_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_SetProfileTheme_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_SetProfileTheme_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_SetProfileTheme_Response {
    fn default() -> &'a CPlayer_SetProfileTheme_Response {
        <CPlayer_SetProfileTheme_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_SetProfileTheme_Response {
    pub fn new() -> CPlayer_SetProfileTheme_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetProfileTheme_Response {
    const NAME: &'static str = "CPlayer_SetProfileTheme_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() -> CPlayer_SetProfileTheme_Response {
        CPlayer_SetProfileTheme_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_SetProfileTheme_Response {
        static instance: CPlayer_SetProfileTheme_Response = CPlayer_SetProfileTheme_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_SetProfilePreferences_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_SetProfilePreferences_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_SetProfilePreferences_Request.profile_preferences)
    pub profile_preferences: ::steam_vent_proto_common::protobuf::MessageField<ProfilePreferences>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_SetProfilePreferences_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_SetProfilePreferences_Request {
    fn default() -> &'a CPlayer_SetProfilePreferences_Request {
        <CPlayer_SetProfilePreferences_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_SetProfilePreferences_Request {
    pub fn new() -> CPlayer_SetProfilePreferences_Request {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetProfilePreferences_Request {
    const NAME: &'static str = "CPlayer_SetProfilePreferences_Request";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.profile_preferences)?;
                },
                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.profile_preferences.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.profile_preferences.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_SetProfilePreferences_Request {
        CPlayer_SetProfilePreferences_Request::new()
    }

    fn clear(&mut self) {
        self.profile_preferences.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_SetProfilePreferences_Request {
        static instance: CPlayer_SetProfilePreferences_Request = CPlayer_SetProfilePreferences_Request {
            profile_preferences: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_SetProfilePreferences_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_SetProfilePreferences_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_SetProfilePreferences_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_SetProfilePreferences_Response {
    fn default() -> &'a CPlayer_SetProfilePreferences_Response {
        <CPlayer_SetProfilePreferences_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_SetProfilePreferences_Response {
    pub fn new() -> CPlayer_SetProfilePreferences_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetProfilePreferences_Response {
    const NAME: &'static str = "CPlayer_SetProfilePreferences_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() -> CPlayer_SetProfilePreferences_Response {
        CPlayer_SetProfilePreferences_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_SetProfilePreferences_Response {
        static instance: CPlayer_SetProfilePreferences_Response = CPlayer_SetProfilePreferences_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_PostStatusToFriends_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_PostStatusToFriends_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_PostStatusToFriends_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_PostStatusToFriends_Request.status_text)
    pub status_text: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_PostStatusToFriends_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_PostStatusToFriends_Request {
    fn default() -> &'a CPlayer_PostStatusToFriends_Request {
        <CPlayer_PostStatusToFriends_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_PostStatusToFriends_Request {
    pub fn new() -> CPlayer_PostStatusToFriends_Request {
        ::std::default::Default::default()
    }

    // optional uint32 appid = 1;

    pub fn appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }

    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

    pub fn has_appid(&self) -> bool {
        self.appid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_appid(&mut self, v: u32) {
        self.appid = ::std::option::Option::Some(v);
    }

    // optional string status_text = 2;

    pub fn status_text(&self) -> &str {
        match self.status_text.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_status_text(&mut self) {
        self.status_text = ::std::option::Option::None;
    }

    pub fn has_status_text(&self) -> bool {
        self.status_text.is_some()
    }

    // Param is passed by value, moved
    pub fn set_status_text(&mut self, v: ::std::string::String) {
        self.status_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_status_text(&mut self) -> &mut ::std::string::String {
        if self.status_text.is_none() {
            self.status_text = ::std::option::Option::Some(::std::string::String::new());
        }
        self.status_text.as_mut().unwrap()
    }

    // Take field
    pub fn take_status_text(&mut self) -> ::std::string::String {
        self.status_text.take().unwrap_or_else(|| ::std::string::String::new())
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_PostStatusToFriends_Request {
    const NAME: &'static str = "CPlayer_PostStatusToFriends_Request";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                18 => {
                    self.status_text = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.status_text.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.status_text.as_ref() {
            os.write_string(2, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_PostStatusToFriends_Request {
        CPlayer_PostStatusToFriends_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.status_text = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_PostStatusToFriends_Request {
        static instance: CPlayer_PostStatusToFriends_Request = CPlayer_PostStatusToFriends_Request {
            appid: ::std::option::Option::None,
            status_text: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_PostStatusToFriends_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_PostStatusToFriends_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_PostStatusToFriends_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_PostStatusToFriends_Response {
    fn default() -> &'a CPlayer_PostStatusToFriends_Response {
        <CPlayer_PostStatusToFriends_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_PostStatusToFriends_Response {
    pub fn new() -> CPlayer_PostStatusToFriends_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_PostStatusToFriends_Response {
    const NAME: &'static str = "CPlayer_PostStatusToFriends_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() -> CPlayer_PostStatusToFriends_Response {
        CPlayer_PostStatusToFriends_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_PostStatusToFriends_Response {
        static instance: CPlayer_PostStatusToFriends_Response = CPlayer_PostStatusToFriends_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetPostedStatus_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetPostedStatus_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetPostedStatus_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CPlayer_GetPostedStatus_Request.postid)
    pub postid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetPostedStatus_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetPostedStatus_Request {
    fn default() -> &'a CPlayer_GetPostedStatus_Request {
        <CPlayer_GetPostedStatus_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetPostedStatus_Request {
    pub fn new() -> CPlayer_GetPostedStatus_Request {
        ::std::default::Default::default()
    }

    // optional uint64 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 uint64 postid = 2;

    pub fn postid(&self) -> u64 {
        self.postid.unwrap_or(0)
    }

    pub fn clear_postid(&mut self) {
        self.postid = ::std::option::Option::None;
    }

    pub fn has_postid(&self) -> bool {
        self.postid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_postid(&mut self, v: u64) {
        self.postid = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetPostedStatus_Request {
    const NAME: &'static str = "CPlayer_GetPostedStatus_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.steamid = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.postid = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.steamid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.postid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.steamid {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.postid {
            os.write_uint64(2, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetPostedStatus_Request {
        CPlayer_GetPostedStatus_Request::new()
    }

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.postid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetPostedStatus_Request {
        static instance: CPlayer_GetPostedStatus_Request = CPlayer_GetPostedStatus_Request {
            steamid: ::std::option::Option::None,
            postid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetPostedStatus_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetPostedStatus_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetPostedStatus_Response.accountid)
    pub accountid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_GetPostedStatus_Response.postid)
    pub postid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CPlayer_GetPostedStatus_Response.status_text)
    pub status_text: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CPlayer_GetPostedStatus_Response.deleted)
    pub deleted: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CPlayer_GetPostedStatus_Response.appid)
    pub appid: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetPostedStatus_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetPostedStatus_Response {
    fn default() -> &'a CPlayer_GetPostedStatus_Response {
        <CPlayer_GetPostedStatus_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetPostedStatus_Response {
    pub fn new() -> CPlayer_GetPostedStatus_Response {
        ::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 uint64 postid = 2;

    pub fn postid(&self) -> u64 {
        self.postid.unwrap_or(0)
    }

    pub fn clear_postid(&mut self) {
        self.postid = ::std::option::Option::None;
    }

    pub fn has_postid(&self) -> bool {
        self.postid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_postid(&mut self, v: u64) {
        self.postid = ::std::option::Option::Some(v);
    }

    // optional string status_text = 3;

    pub fn status_text(&self) -> &str {
        match self.status_text.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_status_text(&mut self) {
        self.status_text = ::std::option::Option::None;
    }

    pub fn has_status_text(&self) -> bool {
        self.status_text.is_some()
    }

    // Param is passed by value, moved
    pub fn set_status_text(&mut self, v: ::std::string::String) {
        self.status_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_status_text(&mut self) -> &mut ::std::string::String {
        if self.status_text.is_none() {
            self.status_text = ::std::option::Option::Some(::std::string::String::new());
        }
        self.status_text.as_mut().unwrap()
    }

    // Take field
    pub fn take_status_text(&mut self) -> ::std::string::String {
        self.status_text.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional bool deleted = 4;

    pub fn deleted(&self) -> bool {
        self.deleted.unwrap_or(false)
    }

    pub fn clear_deleted(&mut self) {
        self.deleted = ::std::option::Option::None;
    }

    pub fn has_deleted(&self) -> bool {
        self.deleted.is_some()
    }

    // Param is passed by value, moved
    pub fn set_deleted(&mut self, v: bool) {
        self.deleted = ::std::option::Option::Some(v);
    }

    // optional uint32 appid = 5;

    pub fn appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }

    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

    pub fn has_appid(&self) -> bool {
        self.appid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_appid(&mut self, v: u32) {
        self.appid = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetPostedStatus_Response {
    const NAME: &'static str = "CPlayer_GetPostedStatus_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.accountid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.postid = ::std::option::Option::Some(is.read_uint64()?);
                },
                26 => {
                    self.status_text = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.deleted = ::std::option::Option::Some(is.read_bool()?);
                },
                40 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.accountid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.postid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.status_text.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.deleted {
            my_size += 1 + 1;
        }
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.accountid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.postid {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.status_text.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.deleted {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(5, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetPostedStatus_Response {
        CPlayer_GetPostedStatus_Response::new()
    }

    fn clear(&mut self) {
        self.accountid = ::std::option::Option::None;
        self.postid = ::std::option::Option::None;
        self.status_text = ::std::option::Option::None;
        self.deleted = ::std::option::Option::None;
        self.appid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetPostedStatus_Response {
        static instance: CPlayer_GetPostedStatus_Response = CPlayer_GetPostedStatus_Response {
            accountid: ::std::option::Option::None,
            postid: ::std::option::Option::None,
            status_text: ::std::option::Option::None,
            deleted: ::std::option::Option::None,
            appid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_DeletePostedStatus_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_DeletePostedStatus_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_DeletePostedStatus_Request.postid)
    pub postid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_DeletePostedStatus_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_DeletePostedStatus_Request {
    fn default() -> &'a CPlayer_DeletePostedStatus_Request {
        <CPlayer_DeletePostedStatus_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_DeletePostedStatus_Request {
    pub fn new() -> CPlayer_DeletePostedStatus_Request {
        ::std::default::Default::default()
    }

    // optional uint64 postid = 1;

    pub fn postid(&self) -> u64 {
        self.postid.unwrap_or(0)
    }

    pub fn clear_postid(&mut self) {
        self.postid = ::std::option::Option::None;
    }

    pub fn has_postid(&self) -> bool {
        self.postid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_postid(&mut self, v: u64) {
        self.postid = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_DeletePostedStatus_Request {
    const NAME: &'static str = "CPlayer_DeletePostedStatus_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.postid = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.postid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.postid {
            os.write_uint64(1, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_DeletePostedStatus_Request {
        CPlayer_DeletePostedStatus_Request::new()
    }

    fn clear(&mut self) {
        self.postid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_DeletePostedStatus_Request {
        static instance: CPlayer_DeletePostedStatus_Request = CPlayer_DeletePostedStatus_Request {
            postid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_DeletePostedStatus_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_DeletePostedStatus_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_DeletePostedStatus_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_DeletePostedStatus_Response {
    fn default() -> &'a CPlayer_DeletePostedStatus_Response {
        <CPlayer_DeletePostedStatus_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_DeletePostedStatus_Response {
    pub fn new() -> CPlayer_DeletePostedStatus_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_DeletePostedStatus_Response {
    const NAME: &'static str = "CPlayer_DeletePostedStatus_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() -> CPlayer_DeletePostedStatus_Response {
        CPlayer_DeletePostedStatus_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_DeletePostedStatus_Response {
        static instance: CPlayer_DeletePostedStatus_Response = CPlayer_DeletePostedStatus_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetLastPlayedTimes_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetLastPlayedTimes_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Request.min_last_played)
    pub min_last_played: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetLastPlayedTimes_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetLastPlayedTimes_Request {
    fn default() -> &'a CPlayer_GetLastPlayedTimes_Request {
        <CPlayer_GetLastPlayedTimes_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetLastPlayedTimes_Request {
    pub fn new() -> CPlayer_GetLastPlayedTimes_Request {
        ::std::default::Default::default()
    }

    // optional uint32 min_last_played = 1;

    pub fn min_last_played(&self) -> u32 {
        self.min_last_played.unwrap_or(0)
    }

    pub fn clear_min_last_played(&mut self) {
        self.min_last_played = ::std::option::Option::None;
    }

    pub fn has_min_last_played(&self) -> bool {
        self.min_last_played.is_some()
    }

    // Param is passed by value, moved
    pub fn set_min_last_played(&mut self, v: u32) {
        self.min_last_played = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetLastPlayedTimes_Request {
    const NAME: &'static str = "CPlayer_GetLastPlayedTimes_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.min_last_played = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.min_last_played {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.min_last_played {
            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() -> CPlayer_GetLastPlayedTimes_Request {
        CPlayer_GetLastPlayedTimes_Request::new()
    }

    fn clear(&mut self) {
        self.min_last_played = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetLastPlayedTimes_Request {
        static instance: CPlayer_GetLastPlayedTimes_Request = CPlayer_GetLastPlayedTimes_Request {
            min_last_played: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetLastPlayedTimes_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetLastPlayedTimes_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.games)
    pub games: ::std::vec::Vec<cplayer_get_last_played_times_response::Game>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetLastPlayedTimes_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetLastPlayedTimes_Response {
    fn default() -> &'a CPlayer_GetLastPlayedTimes_Response {
        <CPlayer_GetLastPlayedTimes_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetLastPlayedTimes_Response {
    pub fn new() -> CPlayer_GetLastPlayedTimes_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetLastPlayedTimes_Response {
    const NAME: &'static str = "CPlayer_GetLastPlayedTimes_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.games.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.games {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.games {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetLastPlayedTimes_Response {
        CPlayer_GetLastPlayedTimes_Response::new()
    }

    fn clear(&mut self) {
        self.games.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetLastPlayedTimes_Response {
        static instance: CPlayer_GetLastPlayedTimes_Response = CPlayer_GetLastPlayedTimes_Response {
            games: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CPlayer_GetLastPlayedTimes_Response`
pub mod cplayer_get_last_played_times_response {
    // @@protoc_insertion_point(message:CPlayer_GetLastPlayedTimes_Response.Game)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Game {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.appid)
        pub appid: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.last_playtime)
        pub last_playtime: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.playtime_2weeks)
        pub playtime_2weeks: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.playtime_forever)
        pub playtime_forever: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.first_playtime)
        pub first_playtime: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.playtime_windows_forever)
        pub playtime_windows_forever: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.playtime_mac_forever)
        pub playtime_mac_forever: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.playtime_linux_forever)
        pub playtime_linux_forever: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.playtime_deck_forever)
        pub playtime_deck_forever: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.first_windows_playtime)
        pub first_windows_playtime: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.first_mac_playtime)
        pub first_mac_playtime: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.first_linux_playtime)
        pub first_linux_playtime: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.first_deck_playtime)
        pub first_deck_playtime: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.last_windows_playtime)
        pub last_windows_playtime: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.last_mac_playtime)
        pub last_mac_playtime: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.last_linux_playtime)
        pub last_linux_playtime: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.last_deck_playtime)
        pub last_deck_playtime: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetLastPlayedTimes_Response.Game.playtime_disconnected)
        pub playtime_disconnected: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetLastPlayedTimes_Response.Game.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

    impl<'a> ::std::default::Default for &'a Game {
        fn default() -> &'a Game {
            <Game as ::steam_vent_proto_common::protobuf::Message>::default_instance()
        }
    }

    impl Game {
        pub fn new() -> Game {
            ::std::default::Default::default()
        }

        // optional int32 appid = 1;

        pub fn appid(&self) -> i32 {
            self.appid.unwrap_or(0)
        }

        pub fn clear_appid(&mut self) {
            self.appid = ::std::option::Option::None;
        }

        pub fn has_appid(&self) -> bool {
            self.appid.is_some()
        }

        // Param is passed by value, moved
        pub fn set_appid(&mut self, v: i32) {
            self.appid = ::std::option::Option::Some(v);
        }

        // optional uint32 last_playtime = 2;

        pub fn last_playtime(&self) -> u32 {
            self.last_playtime.unwrap_or(0)
        }

        pub fn clear_last_playtime(&mut self) {
            self.last_playtime = ::std::option::Option::None;
        }

        pub fn has_last_playtime(&self) -> bool {
            self.last_playtime.is_some()
        }

        // Param is passed by value, moved
        pub fn set_last_playtime(&mut self, v: u32) {
            self.last_playtime = ::std::option::Option::Some(v);
        }

        // optional int32 playtime_2weeks = 3;

        pub fn playtime_2weeks(&self) -> i32 {
            self.playtime_2weeks.unwrap_or(0)
        }

        pub fn clear_playtime_2weeks(&mut self) {
            self.playtime_2weeks = ::std::option::Option::None;
        }

        pub fn has_playtime_2weeks(&self) -> bool {
            self.playtime_2weeks.is_some()
        }

        // Param is passed by value, moved
        pub fn set_playtime_2weeks(&mut self, v: i32) {
            self.playtime_2weeks = ::std::option::Option::Some(v);
        }

        // optional int32 playtime_forever = 4;

        pub fn playtime_forever(&self) -> i32 {
            self.playtime_forever.unwrap_or(0)
        }

        pub fn clear_playtime_forever(&mut self) {
            self.playtime_forever = ::std::option::Option::None;
        }

        pub fn has_playtime_forever(&self) -> bool {
            self.playtime_forever.is_some()
        }

        // Param is passed by value, moved
        pub fn set_playtime_forever(&mut self, v: i32) {
            self.playtime_forever = ::std::option::Option::Some(v);
        }

        // optional uint32 first_playtime = 5;

        pub fn first_playtime(&self) -> u32 {
            self.first_playtime.unwrap_or(0)
        }

        pub fn clear_first_playtime(&mut self) {
            self.first_playtime = ::std::option::Option::None;
        }

        pub fn has_first_playtime(&self) -> bool {
            self.first_playtime.is_some()
        }

        // Param is passed by value, moved
        pub fn set_first_playtime(&mut self, v: u32) {
            self.first_playtime = ::std::option::Option::Some(v);
        }

        // optional int32 playtime_windows_forever = 6;

        pub fn playtime_windows_forever(&self) -> i32 {
            self.playtime_windows_forever.unwrap_or(0)
        }

        pub fn clear_playtime_windows_forever(&mut self) {
            self.playtime_windows_forever = ::std::option::Option::None;
        }

        pub fn has_playtime_windows_forever(&self) -> bool {
            self.playtime_windows_forever.is_some()
        }

        // Param is passed by value, moved
        pub fn set_playtime_windows_forever(&mut self, v: i32) {
            self.playtime_windows_forever = ::std::option::Option::Some(v);
        }

        // optional int32 playtime_mac_forever = 7;

        pub fn playtime_mac_forever(&self) -> i32 {
            self.playtime_mac_forever.unwrap_or(0)
        }

        pub fn clear_playtime_mac_forever(&mut self) {
            self.playtime_mac_forever = ::std::option::Option::None;
        }

        pub fn has_playtime_mac_forever(&self) -> bool {
            self.playtime_mac_forever.is_some()
        }

        // Param is passed by value, moved
        pub fn set_playtime_mac_forever(&mut self, v: i32) {
            self.playtime_mac_forever = ::std::option::Option::Some(v);
        }

        // optional int32 playtime_linux_forever = 8;

        pub fn playtime_linux_forever(&self) -> i32 {
            self.playtime_linux_forever.unwrap_or(0)
        }

        pub fn clear_playtime_linux_forever(&mut self) {
            self.playtime_linux_forever = ::std::option::Option::None;
        }

        pub fn has_playtime_linux_forever(&self) -> bool {
            self.playtime_linux_forever.is_some()
        }

        // Param is passed by value, moved
        pub fn set_playtime_linux_forever(&mut self, v: i32) {
            self.playtime_linux_forever = ::std::option::Option::Some(v);
        }

        // optional int32 playtime_deck_forever = 16;

        pub fn playtime_deck_forever(&self) -> i32 {
            self.playtime_deck_forever.unwrap_or(0)
        }

        pub fn clear_playtime_deck_forever(&mut self) {
            self.playtime_deck_forever = ::std::option::Option::None;
        }

        pub fn has_playtime_deck_forever(&self) -> bool {
            self.playtime_deck_forever.is_some()
        }

        // Param is passed by value, moved
        pub fn set_playtime_deck_forever(&mut self, v: i32) {
            self.playtime_deck_forever = ::std::option::Option::Some(v);
        }

        // optional uint32 first_windows_playtime = 9;

        pub fn first_windows_playtime(&self) -> u32 {
            self.first_windows_playtime.unwrap_or(0)
        }

        pub fn clear_first_windows_playtime(&mut self) {
            self.first_windows_playtime = ::std::option::Option::None;
        }

        pub fn has_first_windows_playtime(&self) -> bool {
            self.first_windows_playtime.is_some()
        }

        // Param is passed by value, moved
        pub fn set_first_windows_playtime(&mut self, v: u32) {
            self.first_windows_playtime = ::std::option::Option::Some(v);
        }

        // optional uint32 first_mac_playtime = 10;

        pub fn first_mac_playtime(&self) -> u32 {
            self.first_mac_playtime.unwrap_or(0)
        }

        pub fn clear_first_mac_playtime(&mut self) {
            self.first_mac_playtime = ::std::option::Option::None;
        }

        pub fn has_first_mac_playtime(&self) -> bool {
            self.first_mac_playtime.is_some()
        }

        // Param is passed by value, moved
        pub fn set_first_mac_playtime(&mut self, v: u32) {
            self.first_mac_playtime = ::std::option::Option::Some(v);
        }

        // optional uint32 first_linux_playtime = 11;

        pub fn first_linux_playtime(&self) -> u32 {
            self.first_linux_playtime.unwrap_or(0)
        }

        pub fn clear_first_linux_playtime(&mut self) {
            self.first_linux_playtime = ::std::option::Option::None;
        }

        pub fn has_first_linux_playtime(&self) -> bool {
            self.first_linux_playtime.is_some()
        }

        // Param is passed by value, moved
        pub fn set_first_linux_playtime(&mut self, v: u32) {
            self.first_linux_playtime = ::std::option::Option::Some(v);
        }

        // optional uint32 first_deck_playtime = 17;

        pub fn first_deck_playtime(&self) -> u32 {
            self.first_deck_playtime.unwrap_or(0)
        }

        pub fn clear_first_deck_playtime(&mut self) {
            self.first_deck_playtime = ::std::option::Option::None;
        }

        pub fn has_first_deck_playtime(&self) -> bool {
            self.first_deck_playtime.is_some()
        }

        // Param is passed by value, moved
        pub fn set_first_deck_playtime(&mut self, v: u32) {
            self.first_deck_playtime = ::std::option::Option::Some(v);
        }

        // optional uint32 last_windows_playtime = 12;

        pub fn last_windows_playtime(&self) -> u32 {
            self.last_windows_playtime.unwrap_or(0)
        }

        pub fn clear_last_windows_playtime(&mut self) {
            self.last_windows_playtime = ::std::option::Option::None;
        }

        pub fn has_last_windows_playtime(&self) -> bool {
            self.last_windows_playtime.is_some()
        }

        // Param is passed by value, moved
        pub fn set_last_windows_playtime(&mut self, v: u32) {
            self.last_windows_playtime = ::std::option::Option::Some(v);
        }

        // optional uint32 last_mac_playtime = 13;

        pub fn last_mac_playtime(&self) -> u32 {
            self.last_mac_playtime.unwrap_or(0)
        }

        pub fn clear_last_mac_playtime(&mut self) {
            self.last_mac_playtime = ::std::option::Option::None;
        }

        pub fn has_last_mac_playtime(&self) -> bool {
            self.last_mac_playtime.is_some()
        }

        // Param is passed by value, moved
        pub fn set_last_mac_playtime(&mut self, v: u32) {
            self.last_mac_playtime = ::std::option::Option::Some(v);
        }

        // optional uint32 last_linux_playtime = 14;

        pub fn last_linux_playtime(&self) -> u32 {
            self.last_linux_playtime.unwrap_or(0)
        }

        pub fn clear_last_linux_playtime(&mut self) {
            self.last_linux_playtime = ::std::option::Option::None;
        }

        pub fn has_last_linux_playtime(&self) -> bool {
            self.last_linux_playtime.is_some()
        }

        // Param is passed by value, moved
        pub fn set_last_linux_playtime(&mut self, v: u32) {
            self.last_linux_playtime = ::std::option::Option::Some(v);
        }

        // optional uint32 last_deck_playtime = 18;

        pub fn last_deck_playtime(&self) -> u32 {
            self.last_deck_playtime.unwrap_or(0)
        }

        pub fn clear_last_deck_playtime(&mut self) {
            self.last_deck_playtime = ::std::option::Option::None;
        }

        pub fn has_last_deck_playtime(&self) -> bool {
            self.last_deck_playtime.is_some()
        }

        // Param is passed by value, moved
        pub fn set_last_deck_playtime(&mut self, v: u32) {
            self.last_deck_playtime = ::std::option::Option::Some(v);
        }

        // optional uint32 playtime_disconnected = 15;

        pub fn playtime_disconnected(&self) -> u32 {
            self.playtime_disconnected.unwrap_or(0)
        }

        pub fn clear_playtime_disconnected(&mut self) {
            self.playtime_disconnected = ::std::option::Option::None;
        }

        pub fn has_playtime_disconnected(&self) -> bool {
            self.playtime_disconnected.is_some()
        }

        // Param is passed by value, moved
        pub fn set_playtime_disconnected(&mut self, v: u32) {
            self.playtime_disconnected = ::std::option::Option::Some(v);
        }
    }

    impl ::steam_vent_proto_common::protobuf::Message for Game {
        const NAME: &'static str = "Game";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.appid = ::std::option::Option::Some(is.read_int32()?);
                    },
                    16 => {
                        self.last_playtime = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    24 => {
                        self.playtime_2weeks = ::std::option::Option::Some(is.read_int32()?);
                    },
                    32 => {
                        self.playtime_forever = ::std::option::Option::Some(is.read_int32()?);
                    },
                    40 => {
                        self.first_playtime = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    48 => {
                        self.playtime_windows_forever = ::std::option::Option::Some(is.read_int32()?);
                    },
                    56 => {
                        self.playtime_mac_forever = ::std::option::Option::Some(is.read_int32()?);
                    },
                    64 => {
                        self.playtime_linux_forever = ::std::option::Option::Some(is.read_int32()?);
                    },
                    128 => {
                        self.playtime_deck_forever = ::std::option::Option::Some(is.read_int32()?);
                    },
                    72 => {
                        self.first_windows_playtime = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    80 => {
                        self.first_mac_playtime = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    88 => {
                        self.first_linux_playtime = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    136 => {
                        self.first_deck_playtime = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    96 => {
                        self.last_windows_playtime = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    104 => {
                        self.last_mac_playtime = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    112 => {
                        self.last_linux_playtime = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    144 => {
                        self.last_deck_playtime = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    120 => {
                        self.playtime_disconnected = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if let Some(v) = self.appid {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
            }
            if let Some(v) = self.last_playtime {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
            }
            if let Some(v) = self.playtime_2weeks {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v);
            }
            if let Some(v) = self.playtime_forever {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v);
            }
            if let Some(v) = self.first_playtime {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
            }
            if let Some(v) = self.playtime_windows_forever {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(6, v);
            }
            if let Some(v) = self.playtime_mac_forever {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(7, v);
            }
            if let Some(v) = self.playtime_linux_forever {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(8, v);
            }
            if let Some(v) = self.playtime_deck_forever {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(16, v);
            }
            if let Some(v) = self.first_windows_playtime {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
            }
            if let Some(v) = self.first_mac_playtime {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(10, v);
            }
            if let Some(v) = self.first_linux_playtime {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(11, v);
            }
            if let Some(v) = self.first_deck_playtime {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(17, v);
            }
            if let Some(v) = self.last_windows_playtime {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(12, v);
            }
            if let Some(v) = self.last_mac_playtime {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(13, v);
            }
            if let Some(v) = self.last_linux_playtime {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(14, v);
            }
            if let Some(v) = self.last_deck_playtime {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(18, v);
            }
            if let Some(v) = self.playtime_disconnected {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(15, v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.appid {
                os.write_int32(1, v)?;
            }
            if let Some(v) = self.last_playtime {
                os.write_uint32(2, v)?;
            }
            if let Some(v) = self.playtime_2weeks {
                os.write_int32(3, v)?;
            }
            if let Some(v) = self.playtime_forever {
                os.write_int32(4, v)?;
            }
            if let Some(v) = self.first_playtime {
                os.write_uint32(5, v)?;
            }
            if let Some(v) = self.playtime_windows_forever {
                os.write_int32(6, v)?;
            }
            if let Some(v) = self.playtime_mac_forever {
                os.write_int32(7, v)?;
            }
            if let Some(v) = self.playtime_linux_forever {
                os.write_int32(8, v)?;
            }
            if let Some(v) = self.playtime_deck_forever {
                os.write_int32(16, v)?;
            }
            if let Some(v) = self.first_windows_playtime {
                os.write_uint32(9, v)?;
            }
            if let Some(v) = self.first_mac_playtime {
                os.write_uint32(10, v)?;
            }
            if let Some(v) = self.first_linux_playtime {
                os.write_uint32(11, v)?;
            }
            if let Some(v) = self.first_deck_playtime {
                os.write_uint32(17, v)?;
            }
            if let Some(v) = self.last_windows_playtime {
                os.write_uint32(12, v)?;
            }
            if let Some(v) = self.last_mac_playtime {
                os.write_uint32(13, v)?;
            }
            if let Some(v) = self.last_linux_playtime {
                os.write_uint32(14, v)?;
            }
            if let Some(v) = self.last_deck_playtime {
                os.write_uint32(18, v)?;
            }
            if let Some(v) = self.playtime_disconnected {
                os.write_uint32(15, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
            &mut self.special_fields
        }

        fn new() -> Game {
            Game::new()
        }

        fn clear(&mut self) {
            self.appid = ::std::option::Option::None;
            self.last_playtime = ::std::option::Option::None;
            self.playtime_2weeks = ::std::option::Option::None;
            self.playtime_forever = ::std::option::Option::None;
            self.first_playtime = ::std::option::Option::None;
            self.playtime_windows_forever = ::std::option::Option::None;
            self.playtime_mac_forever = ::std::option::Option::None;
            self.playtime_linux_forever = ::std::option::Option::None;
            self.playtime_deck_forever = ::std::option::Option::None;
            self.first_windows_playtime = ::std::option::Option::None;
            self.first_mac_playtime = ::std::option::Option::None;
            self.first_linux_playtime = ::std::option::Option::None;
            self.first_deck_playtime = ::std::option::Option::None;
            self.last_windows_playtime = ::std::option::Option::None;
            self.last_mac_playtime = ::std::option::Option::None;
            self.last_linux_playtime = ::std::option::Option::None;
            self.last_deck_playtime = ::std::option::Option::None;
            self.playtime_disconnected = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Game {
            static instance: Game = Game {
                appid: ::std::option::Option::None,
                last_playtime: ::std::option::Option::None,
                playtime_2weeks: ::std::option::Option::None,
                playtime_forever: ::std::option::Option::None,
                first_playtime: ::std::option::Option::None,
                playtime_windows_forever: ::std::option::Option::None,
                playtime_mac_forever: ::std::option::Option::None,
                playtime_linux_forever: ::std::option::Option::None,
                playtime_deck_forever: ::std::option::Option::None,
                first_windows_playtime: ::std::option::Option::None,
                first_mac_playtime: ::std::option::Option::None,
                first_linux_playtime: ::std::option::Option::None,
                first_deck_playtime: ::std::option::Option::None,
                last_windows_playtime: ::std::option::Option::None,
                last_mac_playtime: ::std::option::Option::None,
                last_linux_playtime: ::std::option::Option::None,
                last_deck_playtime: ::std::option::Option::None,
                playtime_disconnected: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CPlayer_GetTimeSSAAccepted_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetTimeSSAAccepted_Request {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetTimeSSAAccepted_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetTimeSSAAccepted_Request {
    fn default() -> &'a CPlayer_GetTimeSSAAccepted_Request {
        <CPlayer_GetTimeSSAAccepted_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetTimeSSAAccepted_Request {
    pub fn new() -> CPlayer_GetTimeSSAAccepted_Request {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetTimeSSAAccepted_Request {
    const NAME: &'static str = "CPlayer_GetTimeSSAAccepted_Request";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetTimeSSAAccepted_Request {
        CPlayer_GetTimeSSAAccepted_Request::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetTimeSSAAccepted_Request {
        static instance: CPlayer_GetTimeSSAAccepted_Request = CPlayer_GetTimeSSAAccepted_Request {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetTimeSSAAccepted_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetTimeSSAAccepted_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetTimeSSAAccepted_Response.time_ssa_accepted)
    pub time_ssa_accepted: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_GetTimeSSAAccepted_Response.time_ssa_updated)
    pub time_ssa_updated: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_GetTimeSSAAccepted_Response.time_chinassa_accepted)
    pub time_chinassa_accepted: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetTimeSSAAccepted_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetTimeSSAAccepted_Response {
    fn default() -> &'a CPlayer_GetTimeSSAAccepted_Response {
        <CPlayer_GetTimeSSAAccepted_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetTimeSSAAccepted_Response {
    pub fn new() -> CPlayer_GetTimeSSAAccepted_Response {
        ::std::default::Default::default()
    }

    // optional uint32 time_ssa_accepted = 1;

    pub fn time_ssa_accepted(&self) -> u32 {
        self.time_ssa_accepted.unwrap_or(0)
    }

    pub fn clear_time_ssa_accepted(&mut self) {
        self.time_ssa_accepted = ::std::option::Option::None;
    }

    pub fn has_time_ssa_accepted(&self) -> bool {
        self.time_ssa_accepted.is_some()
    }

    // Param is passed by value, moved
    pub fn set_time_ssa_accepted(&mut self, v: u32) {
        self.time_ssa_accepted = ::std::option::Option::Some(v);
    }

    // optional uint32 time_ssa_updated = 2;

    pub fn time_ssa_updated(&self) -> u32 {
        self.time_ssa_updated.unwrap_or(0)
    }

    pub fn clear_time_ssa_updated(&mut self) {
        self.time_ssa_updated = ::std::option::Option::None;
    }

    pub fn has_time_ssa_updated(&self) -> bool {
        self.time_ssa_updated.is_some()
    }

    // Param is passed by value, moved
    pub fn set_time_ssa_updated(&mut self, v: u32) {
        self.time_ssa_updated = ::std::option::Option::Some(v);
    }

    // optional uint32 time_chinassa_accepted = 3;

    pub fn time_chinassa_accepted(&self) -> u32 {
        self.time_chinassa_accepted.unwrap_or(0)
    }

    pub fn clear_time_chinassa_accepted(&mut self) {
        self.time_chinassa_accepted = ::std::option::Option::None;
    }

    pub fn has_time_chinassa_accepted(&self) -> bool {
        self.time_chinassa_accepted.is_some()
    }

    // Param is passed by value, moved
    pub fn set_time_chinassa_accepted(&mut self, v: u32) {
        self.time_chinassa_accepted = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetTimeSSAAccepted_Response {
    const NAME: &'static str = "CPlayer_GetTimeSSAAccepted_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.time_ssa_accepted = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.time_ssa_updated = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.time_chinassa_accepted = ::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.time_ssa_accepted {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.time_ssa_updated {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.time_chinassa_accepted {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.time_ssa_accepted {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.time_ssa_updated {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.time_chinassa_accepted {
            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() -> CPlayer_GetTimeSSAAccepted_Response {
        CPlayer_GetTimeSSAAccepted_Response::new()
    }

    fn clear(&mut self) {
        self.time_ssa_accepted = ::std::option::Option::None;
        self.time_ssa_updated = ::std::option::Option::None;
        self.time_chinassa_accepted = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetTimeSSAAccepted_Response {
        static instance: CPlayer_GetTimeSSAAccepted_Response = CPlayer_GetTimeSSAAccepted_Response {
            time_ssa_accepted: ::std::option::Option::None,
            time_ssa_updated: ::std::option::Option::None,
            time_chinassa_accepted: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_AcceptSSA_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_AcceptSSA_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_AcceptSSA_Request.agreement_type)
    pub agreement_type: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<EAgreementType>>,
    // @@protoc_insertion_point(field:CPlayer_AcceptSSA_Request.time_signed_utc)
    pub time_signed_utc: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_AcceptSSA_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_AcceptSSA_Request {
    fn default() -> &'a CPlayer_AcceptSSA_Request {
        <CPlayer_AcceptSSA_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_AcceptSSA_Request {
    pub fn new() -> CPlayer_AcceptSSA_Request {
        ::std::default::Default::default()
    }

    // optional .EAgreementType agreement_type = 1;

    pub fn agreement_type(&self) -> EAgreementType {
        match self.agreement_type {
            Some(e) => e.enum_value_or(EAgreementType::k_EAgreementType_Invalid),
            None => EAgreementType::k_EAgreementType_Invalid,
        }
    }

    pub fn clear_agreement_type(&mut self) {
        self.agreement_type = ::std::option::Option::None;
    }

    pub fn has_agreement_type(&self) -> bool {
        self.agreement_type.is_some()
    }

    // Param is passed by value, moved
    pub fn set_agreement_type(&mut self, v: EAgreementType) {
        self.agreement_type = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional uint32 time_signed_utc = 2;

    pub fn time_signed_utc(&self) -> u32 {
        self.time_signed_utc.unwrap_or(0)
    }

    pub fn clear_time_signed_utc(&mut self) {
        self.time_signed_utc = ::std::option::Option::None;
    }

    pub fn has_time_signed_utc(&self) -> bool {
        self.time_signed_utc.is_some()
    }

    // Param is passed by value, moved
    pub fn set_time_signed_utc(&mut self, v: u32) {
        self.time_signed_utc = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_AcceptSSA_Request {
    const NAME: &'static str = "CPlayer_AcceptSSA_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.agreement_type = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                16 => {
                    self.time_signed_utc = ::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.agreement_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v.value());
        }
        if let Some(v) = self.time_signed_utc {
            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.agreement_type {
            os.write_enum(1, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.time_signed_utc {
            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() -> CPlayer_AcceptSSA_Request {
        CPlayer_AcceptSSA_Request::new()
    }

    fn clear(&mut self) {
        self.agreement_type = ::std::option::Option::None;
        self.time_signed_utc = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_AcceptSSA_Request {
        static instance: CPlayer_AcceptSSA_Request = CPlayer_AcceptSSA_Request {
            agreement_type: ::std::option::Option::None,
            time_signed_utc: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_AcceptSSA_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_AcceptSSA_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_AcceptSSA_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_AcceptSSA_Response {
    fn default() -> &'a CPlayer_AcceptSSA_Response {
        <CPlayer_AcceptSSA_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_AcceptSSA_Response {
    pub fn new() -> CPlayer_AcceptSSA_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_AcceptSSA_Response {
    const NAME: &'static str = "CPlayer_AcceptSSA_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() -> CPlayer_AcceptSSA_Response {
        CPlayer_AcceptSSA_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_AcceptSSA_Response {
        static instance: CPlayer_AcceptSSA_Response = CPlayer_AcceptSSA_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetNicknameList_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetNicknameList_Request {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetNicknameList_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetNicknameList_Request {
    fn default() -> &'a CPlayer_GetNicknameList_Request {
        <CPlayer_GetNicknameList_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetNicknameList_Request {
    pub fn new() -> CPlayer_GetNicknameList_Request {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetNicknameList_Request {
    const NAME: &'static str = "CPlayer_GetNicknameList_Request";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetNicknameList_Request {
        CPlayer_GetNicknameList_Request::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetNicknameList_Request {
        static instance: CPlayer_GetNicknameList_Request = CPlayer_GetNicknameList_Request {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetNicknameList_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetNicknameList_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetNicknameList_Response.nicknames)
    pub nicknames: ::std::vec::Vec<cplayer_get_nickname_list_response::PlayerNickname>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetNicknameList_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetNicknameList_Response {
    fn default() -> &'a CPlayer_GetNicknameList_Response {
        <CPlayer_GetNicknameList_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetNicknameList_Response {
    pub fn new() -> CPlayer_GetNicknameList_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetNicknameList_Response {
    const NAME: &'static str = "CPlayer_GetNicknameList_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.nicknames.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.nicknames {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.nicknames {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetNicknameList_Response {
        CPlayer_GetNicknameList_Response::new()
    }

    fn clear(&mut self) {
        self.nicknames.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetNicknameList_Response {
        static instance: CPlayer_GetNicknameList_Response = CPlayer_GetNicknameList_Response {
            nicknames: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CPlayer_GetNicknameList_Response`
pub mod cplayer_get_nickname_list_response {
    // @@protoc_insertion_point(message:CPlayer_GetNicknameList_Response.PlayerNickname)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct PlayerNickname {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_GetNicknameList_Response.PlayerNickname.accountid)
        pub accountid: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_GetNicknameList_Response.PlayerNickname.nickname)
        pub nickname: ::std::option::Option<::std::string::String>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_GetNicknameList_Response.PlayerNickname.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

    impl<'a> ::std::default::Default for &'a PlayerNickname {
        fn default() -> &'a PlayerNickname {
            <PlayerNickname as ::steam_vent_proto_common::protobuf::Message>::default_instance()
        }
    }

    impl PlayerNickname {
        pub fn new() -> PlayerNickname {
            ::std::default::Default::default()
        }

        // optional fixed32 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 string nickname = 2;

        pub fn nickname(&self) -> &str {
            match self.nickname.as_ref() {
                Some(v) => v,
                None => "",
            }
        }

        pub fn clear_nickname(&mut self) {
            self.nickname = ::std::option::Option::None;
        }

        pub fn has_nickname(&self) -> bool {
            self.nickname.is_some()
        }

        // Param is passed by value, moved
        pub fn set_nickname(&mut self, v: ::std::string::String) {
            self.nickname = ::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_nickname(&mut self) -> &mut ::std::string::String {
            if self.nickname.is_none() {
                self.nickname = ::std::option::Option::Some(::std::string::String::new());
            }
            self.nickname.as_mut().unwrap()
        }

        // Take field
        pub fn take_nickname(&mut self) -> ::std::string::String {
            self.nickname.take().unwrap_or_else(|| ::std::string::String::new())
        }
    }

    impl ::steam_vent_proto_common::protobuf::Message for PlayerNickname {
        const NAME: &'static str = "PlayerNickname";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    13 => {
                        self.accountid = ::std::option::Option::Some(is.read_fixed32()?);
                    },
                    18 => {
                        self.nickname = ::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.accountid {
                my_size += 1 + 4;
            }
            if let Some(v) = self.nickname.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.accountid {
                os.write_fixed32(1, v)?;
            }
            if let Some(v) = self.nickname.as_ref() {
                os.write_string(2, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
            &mut self.special_fields
        }

        fn new() -> PlayerNickname {
            PlayerNickname::new()
        }

        fn clear(&mut self) {
            self.accountid = ::std::option::Option::None;
            self.nickname = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static PlayerNickname {
            static instance: PlayerNickname = PlayerNickname {
                accountid: ::std::option::Option::None,
                nickname: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CPlayer_GetPerFriendPreferences_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetPerFriendPreferences_Request {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetPerFriendPreferences_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetPerFriendPreferences_Request {
    fn default() -> &'a CPlayer_GetPerFriendPreferences_Request {
        <CPlayer_GetPerFriendPreferences_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetPerFriendPreferences_Request {
    pub fn new() -> CPlayer_GetPerFriendPreferences_Request {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetPerFriendPreferences_Request {
    const NAME: &'static str = "CPlayer_GetPerFriendPreferences_Request";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetPerFriendPreferences_Request {
        CPlayer_GetPerFriendPreferences_Request::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetPerFriendPreferences_Request {
        static instance: CPlayer_GetPerFriendPreferences_Request = CPlayer_GetPerFriendPreferences_Request {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:PerFriendPreferences)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PerFriendPreferences {
    // message fields
    // @@protoc_insertion_point(field:PerFriendPreferences.accountid)
    pub accountid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:PerFriendPreferences.nickname)
    pub nickname: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:PerFriendPreferences.notifications_showingame)
    pub notifications_showingame: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<ENotificationSetting>>,
    // @@protoc_insertion_point(field:PerFriendPreferences.notifications_showonline)
    pub notifications_showonline: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<ENotificationSetting>>,
    // @@protoc_insertion_point(field:PerFriendPreferences.notifications_showmessages)
    pub notifications_showmessages: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<ENotificationSetting>>,
    // @@protoc_insertion_point(field:PerFriendPreferences.sounds_showingame)
    pub sounds_showingame: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<ENotificationSetting>>,
    // @@protoc_insertion_point(field:PerFriendPreferences.sounds_showonline)
    pub sounds_showonline: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<ENotificationSetting>>,
    // @@protoc_insertion_point(field:PerFriendPreferences.sounds_showmessages)
    pub sounds_showmessages: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<ENotificationSetting>>,
    // @@protoc_insertion_point(field:PerFriendPreferences.notifications_sendmobile)
    pub notifications_sendmobile: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<ENotificationSetting>>,
    // special fields
    // @@protoc_insertion_point(special_field:PerFriendPreferences.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a PerFriendPreferences {
    fn default() -> &'a PerFriendPreferences {
        <PerFriendPreferences as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl PerFriendPreferences {
    pub fn new() -> PerFriendPreferences {
        ::std::default::Default::default()
    }

    // optional fixed32 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 string nickname = 2;

    pub fn nickname(&self) -> &str {
        match self.nickname.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_nickname(&mut self) {
        self.nickname = ::std::option::Option::None;
    }

    pub fn has_nickname(&self) -> bool {
        self.nickname.is_some()
    }

    // Param is passed by value, moved
    pub fn set_nickname(&mut self, v: ::std::string::String) {
        self.nickname = ::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_nickname(&mut self) -> &mut ::std::string::String {
        if self.nickname.is_none() {
            self.nickname = ::std::option::Option::Some(::std::string::String::new());
        }
        self.nickname.as_mut().unwrap()
    }

    // Take field
    pub fn take_nickname(&mut self) -> ::std::string::String {
        self.nickname.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional .ENotificationSetting notifications_showingame = 3;

    pub fn notifications_showingame(&self) -> ENotificationSetting {
        match self.notifications_showingame {
            Some(e) => e.enum_value_or(ENotificationSetting::k_ENotificationSettingNotifyUseDefault),
            None => ENotificationSetting::k_ENotificationSettingNotifyUseDefault,
        }
    }

    pub fn clear_notifications_showingame(&mut self) {
        self.notifications_showingame = ::std::option::Option::None;
    }

    pub fn has_notifications_showingame(&self) -> bool {
        self.notifications_showingame.is_some()
    }

    // Param is passed by value, moved
    pub fn set_notifications_showingame(&mut self, v: ENotificationSetting) {
        self.notifications_showingame = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional .ENotificationSetting notifications_showonline = 4;

    pub fn notifications_showonline(&self) -> ENotificationSetting {
        match self.notifications_showonline {
            Some(e) => e.enum_value_or(ENotificationSetting::k_ENotificationSettingNotifyUseDefault),
            None => ENotificationSetting::k_ENotificationSettingNotifyUseDefault,
        }
    }

    pub fn clear_notifications_showonline(&mut self) {
        self.notifications_showonline = ::std::option::Option::None;
    }

    pub fn has_notifications_showonline(&self) -> bool {
        self.notifications_showonline.is_some()
    }

    // Param is passed by value, moved
    pub fn set_notifications_showonline(&mut self, v: ENotificationSetting) {
        self.notifications_showonline = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional .ENotificationSetting notifications_showmessages = 5;

    pub fn notifications_showmessages(&self) -> ENotificationSetting {
        match self.notifications_showmessages {
            Some(e) => e.enum_value_or(ENotificationSetting::k_ENotificationSettingNotifyUseDefault),
            None => ENotificationSetting::k_ENotificationSettingNotifyUseDefault,
        }
    }

    pub fn clear_notifications_showmessages(&mut self) {
        self.notifications_showmessages = ::std::option::Option::None;
    }

    pub fn has_notifications_showmessages(&self) -> bool {
        self.notifications_showmessages.is_some()
    }

    // Param is passed by value, moved
    pub fn set_notifications_showmessages(&mut self, v: ENotificationSetting) {
        self.notifications_showmessages = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional .ENotificationSetting sounds_showingame = 6;

    pub fn sounds_showingame(&self) -> ENotificationSetting {
        match self.sounds_showingame {
            Some(e) => e.enum_value_or(ENotificationSetting::k_ENotificationSettingNotifyUseDefault),
            None => ENotificationSetting::k_ENotificationSettingNotifyUseDefault,
        }
    }

    pub fn clear_sounds_showingame(&mut self) {
        self.sounds_showingame = ::std::option::Option::None;
    }

    pub fn has_sounds_showingame(&self) -> bool {
        self.sounds_showingame.is_some()
    }

    // Param is passed by value, moved
    pub fn set_sounds_showingame(&mut self, v: ENotificationSetting) {
        self.sounds_showingame = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional .ENotificationSetting sounds_showonline = 7;

    pub fn sounds_showonline(&self) -> ENotificationSetting {
        match self.sounds_showonline {
            Some(e) => e.enum_value_or(ENotificationSetting::k_ENotificationSettingNotifyUseDefault),
            None => ENotificationSetting::k_ENotificationSettingNotifyUseDefault,
        }
    }

    pub fn clear_sounds_showonline(&mut self) {
        self.sounds_showonline = ::std::option::Option::None;
    }

    pub fn has_sounds_showonline(&self) -> bool {
        self.sounds_showonline.is_some()
    }

    // Param is passed by value, moved
    pub fn set_sounds_showonline(&mut self, v: ENotificationSetting) {
        self.sounds_showonline = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional .ENotificationSetting sounds_showmessages = 8;

    pub fn sounds_showmessages(&self) -> ENotificationSetting {
        match self.sounds_showmessages {
            Some(e) => e.enum_value_or(ENotificationSetting::k_ENotificationSettingNotifyUseDefault),
            None => ENotificationSetting::k_ENotificationSettingNotifyUseDefault,
        }
    }

    pub fn clear_sounds_showmessages(&mut self) {
        self.sounds_showmessages = ::std::option::Option::None;
    }

    pub fn has_sounds_showmessages(&self) -> bool {
        self.sounds_showmessages.is_some()
    }

    // Param is passed by value, moved
    pub fn set_sounds_showmessages(&mut self, v: ENotificationSetting) {
        self.sounds_showmessages = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional .ENotificationSetting notifications_sendmobile = 9;

    pub fn notifications_sendmobile(&self) -> ENotificationSetting {
        match self.notifications_sendmobile {
            Some(e) => e.enum_value_or(ENotificationSetting::k_ENotificationSettingNotifyUseDefault),
            None => ENotificationSetting::k_ENotificationSettingNotifyUseDefault,
        }
    }

    pub fn clear_notifications_sendmobile(&mut self) {
        self.notifications_sendmobile = ::std::option::Option::None;
    }

    pub fn has_notifications_sendmobile(&self) -> bool {
        self.notifications_sendmobile.is_some()
    }

    // Param is passed by value, moved
    pub fn set_notifications_sendmobile(&mut self, v: ENotificationSetting) {
        self.notifications_sendmobile = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }
}

impl ::steam_vent_proto_common::protobuf::Message for PerFriendPreferences {
    const NAME: &'static str = "PerFriendPreferences";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                13 => {
                    self.accountid = ::std::option::Option::Some(is.read_fixed32()?);
                },
                18 => {
                    self.nickname = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.notifications_showingame = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                32 => {
                    self.notifications_showonline = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                40 => {
                    self.notifications_showmessages = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                48 => {
                    self.sounds_showingame = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                56 => {
                    self.sounds_showonline = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                64 => {
                    self.sounds_showmessages = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                72 => {
                    self.notifications_sendmobile = ::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.accountid {
            my_size += 1 + 4;
        }
        if let Some(v) = self.nickname.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.notifications_showingame {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v.value());
        }
        if let Some(v) = self.notifications_showonline {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v.value());
        }
        if let Some(v) = self.notifications_showmessages {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v.value());
        }
        if let Some(v) = self.sounds_showingame {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(6, v.value());
        }
        if let Some(v) = self.sounds_showonline {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(7, v.value());
        }
        if let Some(v) = self.sounds_showmessages {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(8, v.value());
        }
        if let Some(v) = self.notifications_sendmobile {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(9, 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.accountid {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.nickname.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.notifications_showingame {
            os.write_enum(3, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.notifications_showonline {
            os.write_enum(4, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.notifications_showmessages {
            os.write_enum(5, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.sounds_showingame {
            os.write_enum(6, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.sounds_showonline {
            os.write_enum(7, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.sounds_showmessages {
            os.write_enum(8, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.notifications_sendmobile {
            os.write_enum(9, ::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() -> PerFriendPreferences {
        PerFriendPreferences::new()
    }

    fn clear(&mut self) {
        self.accountid = ::std::option::Option::None;
        self.nickname = ::std::option::Option::None;
        self.notifications_showingame = ::std::option::Option::None;
        self.notifications_showonline = ::std::option::Option::None;
        self.notifications_showmessages = ::std::option::Option::None;
        self.sounds_showingame = ::std::option::Option::None;
        self.sounds_showonline = ::std::option::Option::None;
        self.sounds_showmessages = ::std::option::Option::None;
        self.notifications_sendmobile = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static PerFriendPreferences {
        static instance: PerFriendPreferences = PerFriendPreferences {
            accountid: ::std::option::Option::None,
            nickname: ::std::option::Option::None,
            notifications_showingame: ::std::option::Option::None,
            notifications_showonline: ::std::option::Option::None,
            notifications_showmessages: ::std::option::Option::None,
            sounds_showingame: ::std::option::Option::None,
            sounds_showonline: ::std::option::Option::None,
            sounds_showmessages: ::std::option::Option::None,
            notifications_sendmobile: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetPerFriendPreferences_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetPerFriendPreferences_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetPerFriendPreferences_Response.preferences)
    pub preferences: ::std::vec::Vec<PerFriendPreferences>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetPerFriendPreferences_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetPerFriendPreferences_Response {
    fn default() -> &'a CPlayer_GetPerFriendPreferences_Response {
        <CPlayer_GetPerFriendPreferences_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetPerFriendPreferences_Response {
    pub fn new() -> CPlayer_GetPerFriendPreferences_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetPerFriendPreferences_Response {
    const NAME: &'static str = "CPlayer_GetPerFriendPreferences_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.preferences.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.preferences {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.preferences {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetPerFriendPreferences_Response {
        CPlayer_GetPerFriendPreferences_Response::new()
    }

    fn clear(&mut self) {
        self.preferences.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetPerFriendPreferences_Response {
        static instance: CPlayer_GetPerFriendPreferences_Response = CPlayer_GetPerFriendPreferences_Response {
            preferences: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_SetPerFriendPreferences_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_SetPerFriendPreferences_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_SetPerFriendPreferences_Request.preferences)
    pub preferences: ::steam_vent_proto_common::protobuf::MessageField<PerFriendPreferences>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_SetPerFriendPreferences_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_SetPerFriendPreferences_Request {
    fn default() -> &'a CPlayer_SetPerFriendPreferences_Request {
        <CPlayer_SetPerFriendPreferences_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_SetPerFriendPreferences_Request {
    pub fn new() -> CPlayer_SetPerFriendPreferences_Request {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetPerFriendPreferences_Request {
    const NAME: &'static str = "CPlayer_SetPerFriendPreferences_Request";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.preferences)?;
                },
                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.preferences.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.preferences.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_SetPerFriendPreferences_Request {
        CPlayer_SetPerFriendPreferences_Request::new()
    }

    fn clear(&mut self) {
        self.preferences.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_SetPerFriendPreferences_Request {
        static instance: CPlayer_SetPerFriendPreferences_Request = CPlayer_SetPerFriendPreferences_Request {
            preferences: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_SetPerFriendPreferences_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_SetPerFriendPreferences_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_SetPerFriendPreferences_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_SetPerFriendPreferences_Response {
    fn default() -> &'a CPlayer_SetPerFriendPreferences_Response {
        <CPlayer_SetPerFriendPreferences_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_SetPerFriendPreferences_Response {
    pub fn new() -> CPlayer_SetPerFriendPreferences_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetPerFriendPreferences_Response {
    const NAME: &'static str = "CPlayer_SetPerFriendPreferences_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() -> CPlayer_SetPerFriendPreferences_Response {
        CPlayer_SetPerFriendPreferences_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_SetPerFriendPreferences_Response {
        static instance: CPlayer_SetPerFriendPreferences_Response = CPlayer_SetPerFriendPreferences_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_AddFriend_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_AddFriend_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_AddFriend_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_AddFriend_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_AddFriend_Request {
    fn default() -> &'a CPlayer_AddFriend_Request {
        <CPlayer_AddFriend_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_AddFriend_Request {
    pub fn new() -> CPlayer_AddFriend_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 CPlayer_AddFriend_Request {
    const NAME: &'static str = "CPlayer_AddFriend_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() -> CPlayer_AddFriend_Request {
        CPlayer_AddFriend_Request::new()
    }

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_AddFriend_Request {
        static instance: CPlayer_AddFriend_Request = CPlayer_AddFriend_Request {
            steamid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_AddFriend_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_AddFriend_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_AddFriend_Response.invite_sent)
    pub invite_sent: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CPlayer_AddFriend_Response.friend_relationship)
    pub friend_relationship: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_AddFriend_Response.result)
    pub result: ::std::option::Option<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_AddFriend_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_AddFriend_Response {
    fn default() -> &'a CPlayer_AddFriend_Response {
        <CPlayer_AddFriend_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_AddFriend_Response {
    pub fn new() -> CPlayer_AddFriend_Response {
        ::std::default::Default::default()
    }

    // optional bool invite_sent = 1;

    pub fn invite_sent(&self) -> bool {
        self.invite_sent.unwrap_or(false)
    }

    pub fn clear_invite_sent(&mut self) {
        self.invite_sent = ::std::option::Option::None;
    }

    pub fn has_invite_sent(&self) -> bool {
        self.invite_sent.is_some()
    }

    // Param is passed by value, moved
    pub fn set_invite_sent(&mut self, v: bool) {
        self.invite_sent = ::std::option::Option::Some(v);
    }

    // optional uint32 friend_relationship = 2;

    pub fn friend_relationship(&self) -> u32 {
        self.friend_relationship.unwrap_or(0)
    }

    pub fn clear_friend_relationship(&mut self) {
        self.friend_relationship = ::std::option::Option::None;
    }

    pub fn has_friend_relationship(&self) -> bool {
        self.friend_relationship.is_some()
    }

    // Param is passed by value, moved
    pub fn set_friend_relationship(&mut self, v: u32) {
        self.friend_relationship = ::std::option::Option::Some(v);
    }

    // optional int32 result = 3;

    pub fn result(&self) -> i32 {
        self.result.unwrap_or(0)
    }

    pub fn clear_result(&mut self) {
        self.result = ::std::option::Option::None;
    }

    pub fn has_result(&self) -> bool {
        self.result.is_some()
    }

    // Param is passed by value, moved
    pub fn set_result(&mut self, v: i32) {
        self.result = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_AddFriend_Response {
    const NAME: &'static str = "CPlayer_AddFriend_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.invite_sent = ::std::option::Option::Some(is.read_bool()?);
                },
                16 => {
                    self.friend_relationship = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.result = ::std::option::Option::Some(is.read_int32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.invite_sent {
            my_size += 1 + 1;
        }
        if let Some(v) = self.friend_relationship {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.result {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.invite_sent {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.friend_relationship {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.result {
            os.write_int32(3, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_AddFriend_Response {
        CPlayer_AddFriend_Response::new()
    }

    fn clear(&mut self) {
        self.invite_sent = ::std::option::Option::None;
        self.friend_relationship = ::std::option::Option::None;
        self.result = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_AddFriend_Response {
        static instance: CPlayer_AddFriend_Response = CPlayer_AddFriend_Response {
            invite_sent: ::std::option::Option::None,
            friend_relationship: ::std::option::Option::None,
            result: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_RemoveFriend_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_RemoveFriend_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_RemoveFriend_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_RemoveFriend_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_RemoveFriend_Request {
    fn default() -> &'a CPlayer_RemoveFriend_Request {
        <CPlayer_RemoveFriend_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_RemoveFriend_Request {
    pub fn new() -> CPlayer_RemoveFriend_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 CPlayer_RemoveFriend_Request {
    const NAME: &'static str = "CPlayer_RemoveFriend_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() -> CPlayer_RemoveFriend_Request {
        CPlayer_RemoveFriend_Request::new()
    }

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_RemoveFriend_Request {
        static instance: CPlayer_RemoveFriend_Request = CPlayer_RemoveFriend_Request {
            steamid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_RemoveFriend_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_RemoveFriend_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_RemoveFriend_Response.friend_relationship)
    pub friend_relationship: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_RemoveFriend_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_RemoveFriend_Response {
    fn default() -> &'a CPlayer_RemoveFriend_Response {
        <CPlayer_RemoveFriend_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_RemoveFriend_Response {
    pub fn new() -> CPlayer_RemoveFriend_Response {
        ::std::default::Default::default()
    }

    // optional uint32 friend_relationship = 1;

    pub fn friend_relationship(&self) -> u32 {
        self.friend_relationship.unwrap_or(0)
    }

    pub fn clear_friend_relationship(&mut self) {
        self.friend_relationship = ::std::option::Option::None;
    }

    pub fn has_friend_relationship(&self) -> bool {
        self.friend_relationship.is_some()
    }

    // Param is passed by value, moved
    pub fn set_friend_relationship(&mut self, v: u32) {
        self.friend_relationship = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_RemoveFriend_Response {
    const NAME: &'static str = "CPlayer_RemoveFriend_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.friend_relationship = ::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.friend_relationship {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.friend_relationship {
            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() -> CPlayer_RemoveFriend_Response {
        CPlayer_RemoveFriend_Response::new()
    }

    fn clear(&mut self) {
        self.friend_relationship = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_RemoveFriend_Response {
        static instance: CPlayer_RemoveFriend_Response = CPlayer_RemoveFriend_Response {
            friend_relationship: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_IgnoreFriend_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_IgnoreFriend_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_IgnoreFriend_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CPlayer_IgnoreFriend_Request.unignore)
    pub unignore: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_IgnoreFriend_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_IgnoreFriend_Request {
    fn default() -> &'a CPlayer_IgnoreFriend_Request {
        <CPlayer_IgnoreFriend_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_IgnoreFriend_Request {
    pub fn new() -> CPlayer_IgnoreFriend_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 bool unignore = 2;

    pub fn unignore(&self) -> bool {
        self.unignore.unwrap_or(false)
    }

    pub fn clear_unignore(&mut self) {
        self.unignore = ::std::option::Option::None;
    }

    pub fn has_unignore(&self) -> bool {
        self.unignore.is_some()
    }

    // Param is passed by value, moved
    pub fn set_unignore(&mut self, v: bool) {
        self.unignore = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_IgnoreFriend_Request {
    const NAME: &'static str = "CPlayer_IgnoreFriend_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.unignore = ::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.unignore {
            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.unignore {
            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() -> CPlayer_IgnoreFriend_Request {
        CPlayer_IgnoreFriend_Request::new()
    }

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.unignore = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_IgnoreFriend_Request {
        static instance: CPlayer_IgnoreFriend_Request = CPlayer_IgnoreFriend_Request {
            steamid: ::std::option::Option::None,
            unignore: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_IgnoreFriend_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_IgnoreFriend_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_IgnoreFriend_Response.friend_relationship)
    pub friend_relationship: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_IgnoreFriend_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_IgnoreFriend_Response {
    fn default() -> &'a CPlayer_IgnoreFriend_Response {
        <CPlayer_IgnoreFriend_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_IgnoreFriend_Response {
    pub fn new() -> CPlayer_IgnoreFriend_Response {
        ::std::default::Default::default()
    }

    // optional uint32 friend_relationship = 1;

    pub fn friend_relationship(&self) -> u32 {
        self.friend_relationship.unwrap_or(0)
    }

    pub fn clear_friend_relationship(&mut self) {
        self.friend_relationship = ::std::option::Option::None;
    }

    pub fn has_friend_relationship(&self) -> bool {
        self.friend_relationship.is_some()
    }

    // Param is passed by value, moved
    pub fn set_friend_relationship(&mut self, v: u32) {
        self.friend_relationship = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_IgnoreFriend_Response {
    const NAME: &'static str = "CPlayer_IgnoreFriend_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.friend_relationship = ::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.friend_relationship {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.friend_relationship {
            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() -> CPlayer_IgnoreFriend_Response {
        CPlayer_IgnoreFriend_Response::new()
    }

    fn clear(&mut self) {
        self.friend_relationship = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_IgnoreFriend_Response {
        static instance: CPlayer_IgnoreFriend_Response = CPlayer_IgnoreFriend_Response {
            friend_relationship: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetCommunityPreferences_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetCommunityPreferences_Request {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetCommunityPreferences_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetCommunityPreferences_Request {
    fn default() -> &'a CPlayer_GetCommunityPreferences_Request {
        <CPlayer_GetCommunityPreferences_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetCommunityPreferences_Request {
    pub fn new() -> CPlayer_GetCommunityPreferences_Request {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetCommunityPreferences_Request {
    const NAME: &'static str = "CPlayer_GetCommunityPreferences_Request";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetCommunityPreferences_Request {
        CPlayer_GetCommunityPreferences_Request::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetCommunityPreferences_Request {
        static instance: CPlayer_GetCommunityPreferences_Request = CPlayer_GetCommunityPreferences_Request {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_CommunityPreferences)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_CommunityPreferences {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_CommunityPreferences.parenthesize_nicknames)
    pub parenthesize_nicknames: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CPlayer_CommunityPreferences.text_filter_setting)
    pub text_filter_setting: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<ETextFilterSetting>>,
    // @@protoc_insertion_point(field:CPlayer_CommunityPreferences.text_filter_ignore_friends)
    pub text_filter_ignore_friends: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CPlayer_CommunityPreferences.text_filter_words_revision)
    pub text_filter_words_revision: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_CommunityPreferences.timestamp_updated)
    pub timestamp_updated: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_CommunityPreferences.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_CommunityPreferences {
    fn default() -> &'a CPlayer_CommunityPreferences {
        <CPlayer_CommunityPreferences as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_CommunityPreferences {
    pub fn new() -> CPlayer_CommunityPreferences {
        ::std::default::Default::default()
    }

    // optional bool parenthesize_nicknames = 4;

    pub fn parenthesize_nicknames(&self) -> bool {
        self.parenthesize_nicknames.unwrap_or(false)
    }

    pub fn clear_parenthesize_nicknames(&mut self) {
        self.parenthesize_nicknames = ::std::option::Option::None;
    }

    pub fn has_parenthesize_nicknames(&self) -> bool {
        self.parenthesize_nicknames.is_some()
    }

    // Param is passed by value, moved
    pub fn set_parenthesize_nicknames(&mut self, v: bool) {
        self.parenthesize_nicknames = ::std::option::Option::Some(v);
    }

    // optional .ETextFilterSetting text_filter_setting = 5;

    pub fn text_filter_setting(&self) -> ETextFilterSetting {
        match self.text_filter_setting {
            Some(e) => e.enum_value_or(ETextFilterSetting::k_ETextFilterSettingSteamLabOptedOut),
            None => ETextFilterSetting::k_ETextFilterSettingSteamLabOptedOut,
        }
    }

    pub fn clear_text_filter_setting(&mut self) {
        self.text_filter_setting = ::std::option::Option::None;
    }

    pub fn has_text_filter_setting(&self) -> bool {
        self.text_filter_setting.is_some()
    }

    // Param is passed by value, moved
    pub fn set_text_filter_setting(&mut self, v: ETextFilterSetting) {
        self.text_filter_setting = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional bool text_filter_ignore_friends = 6;

    pub fn text_filter_ignore_friends(&self) -> bool {
        self.text_filter_ignore_friends.unwrap_or(true)
    }

    pub fn clear_text_filter_ignore_friends(&mut self) {
        self.text_filter_ignore_friends = ::std::option::Option::None;
    }

    pub fn has_text_filter_ignore_friends(&self) -> bool {
        self.text_filter_ignore_friends.is_some()
    }

    // Param is passed by value, moved
    pub fn set_text_filter_ignore_friends(&mut self, v: bool) {
        self.text_filter_ignore_friends = ::std::option::Option::Some(v);
    }

    // optional uint32 text_filter_words_revision = 7;

    pub fn text_filter_words_revision(&self) -> u32 {
        self.text_filter_words_revision.unwrap_or(0)
    }

    pub fn clear_text_filter_words_revision(&mut self) {
        self.text_filter_words_revision = ::std::option::Option::None;
    }

    pub fn has_text_filter_words_revision(&self) -> bool {
        self.text_filter_words_revision.is_some()
    }

    // Param is passed by value, moved
    pub fn set_text_filter_words_revision(&mut self, v: u32) {
        self.text_filter_words_revision = ::std::option::Option::Some(v);
    }

    // optional uint32 timestamp_updated = 3;

    pub fn timestamp_updated(&self) -> u32 {
        self.timestamp_updated.unwrap_or(0)
    }

    pub fn clear_timestamp_updated(&mut self) {
        self.timestamp_updated = ::std::option::Option::None;
    }

    pub fn has_timestamp_updated(&self) -> bool {
        self.timestamp_updated.is_some()
    }

    // Param is passed by value, moved
    pub fn set_timestamp_updated(&mut self, v: u32) {
        self.timestamp_updated = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_CommunityPreferences {
    const NAME: &'static str = "CPlayer_CommunityPreferences";

    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 {
                32 => {
                    self.parenthesize_nicknames = ::std::option::Option::Some(is.read_bool()?);
                },
                40 => {
                    self.text_filter_setting = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                48 => {
                    self.text_filter_ignore_friends = ::std::option::Option::Some(is.read_bool()?);
                },
                56 => {
                    self.text_filter_words_revision = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.timestamp_updated = ::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.parenthesize_nicknames {
            my_size += 1 + 1;
        }
        if let Some(v) = self.text_filter_setting {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v.value());
        }
        if let Some(v) = self.text_filter_ignore_friends {
            my_size += 1 + 1;
        }
        if let Some(v) = self.text_filter_words_revision {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.timestamp_updated {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.parenthesize_nicknames {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.text_filter_setting {
            os.write_enum(5, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.text_filter_ignore_friends {
            os.write_bool(6, v)?;
        }
        if let Some(v) = self.text_filter_words_revision {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.timestamp_updated {
            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() -> CPlayer_CommunityPreferences {
        CPlayer_CommunityPreferences::new()
    }

    fn clear(&mut self) {
        self.parenthesize_nicknames = ::std::option::Option::None;
        self.text_filter_setting = ::std::option::Option::None;
        self.text_filter_ignore_friends = ::std::option::Option::None;
        self.text_filter_words_revision = ::std::option::Option::None;
        self.timestamp_updated = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_CommunityPreferences {
        static instance: CPlayer_CommunityPreferences = CPlayer_CommunityPreferences {
            parenthesize_nicknames: ::std::option::Option::None,
            text_filter_setting: ::std::option::Option::None,
            text_filter_ignore_friends: ::std::option::Option::None,
            text_filter_words_revision: ::std::option::Option::None,
            timestamp_updated: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetCommunityPreferences_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetCommunityPreferences_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetCommunityPreferences_Response.preferences)
    pub preferences: ::steam_vent_proto_common::protobuf::MessageField<CPlayer_CommunityPreferences>,
    // @@protoc_insertion_point(field:CPlayer_GetCommunityPreferences_Response.content_descriptor_preferences)
    pub content_descriptor_preferences: ::steam_vent_proto_common::protobuf::MessageField<super::steammessages_base::UserContentDescriptorPreferences>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetCommunityPreferences_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetCommunityPreferences_Response {
    fn default() -> &'a CPlayer_GetCommunityPreferences_Response {
        <CPlayer_GetCommunityPreferences_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetCommunityPreferences_Response {
    pub fn new() -> CPlayer_GetCommunityPreferences_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetCommunityPreferences_Response {
    const NAME: &'static str = "CPlayer_GetCommunityPreferences_Response";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.preferences)?;
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.content_descriptor_preferences)?;
                },
                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.preferences.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.content_descriptor_preferences.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.preferences.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.content_descriptor_preferences.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetCommunityPreferences_Response {
        CPlayer_GetCommunityPreferences_Response::new()
    }

    fn clear(&mut self) {
        self.preferences.clear();
        self.content_descriptor_preferences.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetCommunityPreferences_Response {
        static instance: CPlayer_GetCommunityPreferences_Response = CPlayer_GetCommunityPreferences_Response {
            preferences: ::steam_vent_proto_common::protobuf::MessageField::none(),
            content_descriptor_preferences: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_SetCommunityPreferences_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_SetCommunityPreferences_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_SetCommunityPreferences_Request.preferences)
    pub preferences: ::steam_vent_proto_common::protobuf::MessageField<CPlayer_CommunityPreferences>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_SetCommunityPreferences_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_SetCommunityPreferences_Request {
    fn default() -> &'a CPlayer_SetCommunityPreferences_Request {
        <CPlayer_SetCommunityPreferences_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_SetCommunityPreferences_Request {
    pub fn new() -> CPlayer_SetCommunityPreferences_Request {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetCommunityPreferences_Request {
    const NAME: &'static str = "CPlayer_SetCommunityPreferences_Request";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.preferences)?;
                },
                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.preferences.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.preferences.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_SetCommunityPreferences_Request {
        CPlayer_SetCommunityPreferences_Request::new()
    }

    fn clear(&mut self) {
        self.preferences.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_SetCommunityPreferences_Request {
        static instance: CPlayer_SetCommunityPreferences_Request = CPlayer_SetCommunityPreferences_Request {
            preferences: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_SetCommunityPreferences_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_SetCommunityPreferences_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_SetCommunityPreferences_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_SetCommunityPreferences_Response {
    fn default() -> &'a CPlayer_SetCommunityPreferences_Response {
        <CPlayer_SetCommunityPreferences_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_SetCommunityPreferences_Response {
    pub fn new() -> CPlayer_SetCommunityPreferences_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_SetCommunityPreferences_Response {
    const NAME: &'static str = "CPlayer_SetCommunityPreferences_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() -> CPlayer_SetCommunityPreferences_Response {
        CPlayer_SetCommunityPreferences_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_SetCommunityPreferences_Response {
        static instance: CPlayer_SetCommunityPreferences_Response = CPlayer_SetCommunityPreferences_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetTextFilterWords_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetTextFilterWords_Request {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetTextFilterWords_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetTextFilterWords_Request {
    fn default() -> &'a CPlayer_GetTextFilterWords_Request {
        <CPlayer_GetTextFilterWords_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetTextFilterWords_Request {
    pub fn new() -> CPlayer_GetTextFilterWords_Request {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetTextFilterWords_Request {
    const NAME: &'static str = "CPlayer_GetTextFilterWords_Request";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetTextFilterWords_Request {
        CPlayer_GetTextFilterWords_Request::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetTextFilterWords_Request {
        static instance: CPlayer_GetTextFilterWords_Request = CPlayer_GetTextFilterWords_Request {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_TextFilterWords)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_TextFilterWords {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_TextFilterWords.text_filter_custom_banned_words)
    pub text_filter_custom_banned_words: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CPlayer_TextFilterWords.text_filter_custom_clean_words)
    pub text_filter_custom_clean_words: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CPlayer_TextFilterWords.text_filter_words_revision)
    pub text_filter_words_revision: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_TextFilterWords.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_TextFilterWords {
    fn default() -> &'a CPlayer_TextFilterWords {
        <CPlayer_TextFilterWords as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_TextFilterWords {
    pub fn new() -> CPlayer_TextFilterWords {
        ::std::default::Default::default()
    }

    // optional uint32 text_filter_words_revision = 3;

    pub fn text_filter_words_revision(&self) -> u32 {
        self.text_filter_words_revision.unwrap_or(0)
    }

    pub fn clear_text_filter_words_revision(&mut self) {
        self.text_filter_words_revision = ::std::option::Option::None;
    }

    pub fn has_text_filter_words_revision(&self) -> bool {
        self.text_filter_words_revision.is_some()
    }

    // Param is passed by value, moved
    pub fn set_text_filter_words_revision(&mut self, v: u32) {
        self.text_filter_words_revision = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_TextFilterWords {
    const NAME: &'static str = "CPlayer_TextFilterWords";

    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.text_filter_custom_banned_words.push(is.read_string()?);
                },
                18 => {
                    self.text_filter_custom_clean_words.push(is.read_string()?);
                },
                24 => {
                    self.text_filter_words_revision = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.text_filter_custom_banned_words {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &value);
        };
        for value in &self.text_filter_custom_clean_words {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &value);
        };
        if let Some(v) = self.text_filter_words_revision {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.text_filter_custom_banned_words {
            os.write_string(1, &v)?;
        };
        for v in &self.text_filter_custom_clean_words {
            os.write_string(2, &v)?;
        };
        if let Some(v) = self.text_filter_words_revision {
            os.write_uint32(3, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_TextFilterWords {
        CPlayer_TextFilterWords::new()
    }

    fn clear(&mut self) {
        self.text_filter_custom_banned_words.clear();
        self.text_filter_custom_clean_words.clear();
        self.text_filter_words_revision = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_TextFilterWords {
        static instance: CPlayer_TextFilterWords = CPlayer_TextFilterWords {
            text_filter_custom_banned_words: ::std::vec::Vec::new(),
            text_filter_custom_clean_words: ::std::vec::Vec::new(),
            text_filter_words_revision: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetTextFilterWords_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetTextFilterWords_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetTextFilterWords_Response.words)
    pub words: ::steam_vent_proto_common::protobuf::MessageField<CPlayer_TextFilterWords>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetTextFilterWords_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetTextFilterWords_Response {
    fn default() -> &'a CPlayer_GetTextFilterWords_Response {
        <CPlayer_GetTextFilterWords_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetTextFilterWords_Response {
    pub fn new() -> CPlayer_GetTextFilterWords_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetTextFilterWords_Response {
    const NAME: &'static str = "CPlayer_GetTextFilterWords_Response";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.words)?;
                },
                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.words.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.words.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetTextFilterWords_Response {
        CPlayer_GetTextFilterWords_Response::new()
    }

    fn clear(&mut self) {
        self.words.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetTextFilterWords_Response {
        static instance: CPlayer_GetTextFilterWords_Response = CPlayer_GetTextFilterWords_Response {
            words: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetNewSteamAnnouncementState_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetNewSteamAnnouncementState_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetNewSteamAnnouncementState_Request.language)
    pub language: ::std::option::Option<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetNewSteamAnnouncementState_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetNewSteamAnnouncementState_Request {
    fn default() -> &'a CPlayer_GetNewSteamAnnouncementState_Request {
        <CPlayer_GetNewSteamAnnouncementState_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetNewSteamAnnouncementState_Request {
    pub fn new() -> CPlayer_GetNewSteamAnnouncementState_Request {
        ::std::default::Default::default()
    }

    // optional int32 language = 1;

    pub fn language(&self) -> i32 {
        self.language.unwrap_or(0)
    }

    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: i32) {
        self.language = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetNewSteamAnnouncementState_Request {
    const NAME: &'static str = "CPlayer_GetNewSteamAnnouncementState_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.language = ::std::option::Option::Some(is.read_int32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.language {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.language {
            os.write_int32(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() -> CPlayer_GetNewSteamAnnouncementState_Request {
        CPlayer_GetNewSteamAnnouncementState_Request::new()
    }

    fn clear(&mut self) {
        self.language = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetNewSteamAnnouncementState_Request {
        static instance: CPlayer_GetNewSteamAnnouncementState_Request = CPlayer_GetNewSteamAnnouncementState_Request {
            language: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetNewSteamAnnouncementState_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetNewSteamAnnouncementState_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetNewSteamAnnouncementState_Response.state)
    pub state: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::enums::ENewSteamAnnouncementState>>,
    // @@protoc_insertion_point(field:CPlayer_GetNewSteamAnnouncementState_Response.announcement_headline)
    pub announcement_headline: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CPlayer_GetNewSteamAnnouncementState_Response.announcement_url)
    pub announcement_url: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CPlayer_GetNewSteamAnnouncementState_Response.time_posted)
    pub time_posted: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_GetNewSteamAnnouncementState_Response.announcement_gid)
    pub announcement_gid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetNewSteamAnnouncementState_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetNewSteamAnnouncementState_Response {
    fn default() -> &'a CPlayer_GetNewSteamAnnouncementState_Response {
        <CPlayer_GetNewSteamAnnouncementState_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetNewSteamAnnouncementState_Response {
    pub fn new() -> CPlayer_GetNewSteamAnnouncementState_Response {
        ::std::default::Default::default()
    }

    // optional .ENewSteamAnnouncementState state = 1;

    pub fn state(&self) -> super::enums::ENewSteamAnnouncementState {
        match self.state {
            Some(e) => e.enum_value_or(super::enums::ENewSteamAnnouncementState::k_ENewSteamAnnouncementState_Invalid),
            None => super::enums::ENewSteamAnnouncementState::k_ENewSteamAnnouncementState_Invalid,
        }
    }

    pub fn clear_state(&mut self) {
        self.state = ::std::option::Option::None;
    }

    pub fn has_state(&self) -> bool {
        self.state.is_some()
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: super::enums::ENewSteamAnnouncementState) {
        self.state = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional string announcement_headline = 2;

    pub fn announcement_headline(&self) -> &str {
        match self.announcement_headline.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_announcement_headline(&mut self) {
        self.announcement_headline = ::std::option::Option::None;
    }

    pub fn has_announcement_headline(&self) -> bool {
        self.announcement_headline.is_some()
    }

    // Param is passed by value, moved
    pub fn set_announcement_headline(&mut self, v: ::std::string::String) {
        self.announcement_headline = ::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_announcement_headline(&mut self) -> &mut ::std::string::String {
        if self.announcement_headline.is_none() {
            self.announcement_headline = ::std::option::Option::Some(::std::string::String::new());
        }
        self.announcement_headline.as_mut().unwrap()
    }

    // Take field
    pub fn take_announcement_headline(&mut self) -> ::std::string::String {
        self.announcement_headline.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string announcement_url = 3;

    pub fn announcement_url(&self) -> &str {
        match self.announcement_url.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_announcement_url(&mut self) {
        self.announcement_url = ::std::option::Option::None;
    }

    pub fn has_announcement_url(&self) -> bool {
        self.announcement_url.is_some()
    }

    // Param is passed by value, moved
    pub fn set_announcement_url(&mut self, v: ::std::string::String) {
        self.announcement_url = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_announcement_url(&mut self) -> &mut ::std::string::String {
        if self.announcement_url.is_none() {
            self.announcement_url = ::std::option::Option::Some(::std::string::String::new());
        }
        self.announcement_url.as_mut().unwrap()
    }

    // Take field
    pub fn take_announcement_url(&mut self) -> ::std::string::String {
        self.announcement_url.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional uint32 time_posted = 4;

    pub fn time_posted(&self) -> u32 {
        self.time_posted.unwrap_or(0)
    }

    pub fn clear_time_posted(&mut self) {
        self.time_posted = ::std::option::Option::None;
    }

    pub fn has_time_posted(&self) -> bool {
        self.time_posted.is_some()
    }

    // Param is passed by value, moved
    pub fn set_time_posted(&mut self, v: u32) {
        self.time_posted = ::std::option::Option::Some(v);
    }

    // optional uint64 announcement_gid = 5;

    pub fn announcement_gid(&self) -> u64 {
        self.announcement_gid.unwrap_or(0)
    }

    pub fn clear_announcement_gid(&mut self) {
        self.announcement_gid = ::std::option::Option::None;
    }

    pub fn has_announcement_gid(&self) -> bool {
        self.announcement_gid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_announcement_gid(&mut self, v: u64) {
        self.announcement_gid = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetNewSteamAnnouncementState_Response {
    const NAME: &'static str = "CPlayer_GetNewSteamAnnouncementState_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.state = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                18 => {
                    self.announcement_headline = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    self.announcement_url = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.time_posted = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.announcement_gid = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.state {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v.value());
        }
        if let Some(v) = self.announcement_headline.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.announcement_url.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.time_posted {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.announcement_gid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(5, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.state {
            os.write_enum(1, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.announcement_headline.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.announcement_url.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.time_posted {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.announcement_gid {
            os.write_uint64(5, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetNewSteamAnnouncementState_Response {
        CPlayer_GetNewSteamAnnouncementState_Response::new()
    }

    fn clear(&mut self) {
        self.state = ::std::option::Option::None;
        self.announcement_headline = ::std::option::Option::None;
        self.announcement_url = ::std::option::Option::None;
        self.time_posted = ::std::option::Option::None;
        self.announcement_gid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetNewSteamAnnouncementState_Response {
        static instance: CPlayer_GetNewSteamAnnouncementState_Response = CPlayer_GetNewSteamAnnouncementState_Response {
            state: ::std::option::Option::None,
            announcement_headline: ::std::option::Option::None,
            announcement_url: ::std::option::Option::None,
            time_posted: ::std::option::Option::None,
            announcement_gid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_UpdateSteamAnnouncementLastRead_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_UpdateSteamAnnouncementLastRead_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_UpdateSteamAnnouncementLastRead_Request.announcement_gid)
    pub announcement_gid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CPlayer_UpdateSteamAnnouncementLastRead_Request.time_posted)
    pub time_posted: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_UpdateSteamAnnouncementLastRead_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_UpdateSteamAnnouncementLastRead_Request {
    fn default() -> &'a CPlayer_UpdateSteamAnnouncementLastRead_Request {
        <CPlayer_UpdateSteamAnnouncementLastRead_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_UpdateSteamAnnouncementLastRead_Request {
    pub fn new() -> CPlayer_UpdateSteamAnnouncementLastRead_Request {
        ::std::default::Default::default()
    }

    // optional uint64 announcement_gid = 1;

    pub fn announcement_gid(&self) -> u64 {
        self.announcement_gid.unwrap_or(0)
    }

    pub fn clear_announcement_gid(&mut self) {
        self.announcement_gid = ::std::option::Option::None;
    }

    pub fn has_announcement_gid(&self) -> bool {
        self.announcement_gid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_announcement_gid(&mut self, v: u64) {
        self.announcement_gid = ::std::option::Option::Some(v);
    }

    // optional uint32 time_posted = 2;

    pub fn time_posted(&self) -> u32 {
        self.time_posted.unwrap_or(0)
    }

    pub fn clear_time_posted(&mut self) {
        self.time_posted = ::std::option::Option::None;
    }

    pub fn has_time_posted(&self) -> bool {
        self.time_posted.is_some()
    }

    // Param is passed by value, moved
    pub fn set_time_posted(&mut self, v: u32) {
        self.time_posted = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_UpdateSteamAnnouncementLastRead_Request {
    const NAME: &'static str = "CPlayer_UpdateSteamAnnouncementLastRead_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.announcement_gid = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.time_posted = ::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.announcement_gid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.time_posted {
            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.announcement_gid {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.time_posted {
            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() -> CPlayer_UpdateSteamAnnouncementLastRead_Request {
        CPlayer_UpdateSteamAnnouncementLastRead_Request::new()
    }

    fn clear(&mut self) {
        self.announcement_gid = ::std::option::Option::None;
        self.time_posted = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_UpdateSteamAnnouncementLastRead_Request {
        static instance: CPlayer_UpdateSteamAnnouncementLastRead_Request = CPlayer_UpdateSteamAnnouncementLastRead_Request {
            announcement_gid: ::std::option::Option::None,
            time_posted: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_UpdateSteamAnnouncementLastRead_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_UpdateSteamAnnouncementLastRead_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_UpdateSteamAnnouncementLastRead_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_UpdateSteamAnnouncementLastRead_Response {
    fn default() -> &'a CPlayer_UpdateSteamAnnouncementLastRead_Response {
        <CPlayer_UpdateSteamAnnouncementLastRead_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_UpdateSteamAnnouncementLastRead_Response {
    pub fn new() -> CPlayer_UpdateSteamAnnouncementLastRead_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_UpdateSteamAnnouncementLastRead_Response {
    const NAME: &'static str = "CPlayer_UpdateSteamAnnouncementLastRead_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() -> CPlayer_UpdateSteamAnnouncementLastRead_Response {
        CPlayer_UpdateSteamAnnouncementLastRead_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_UpdateSteamAnnouncementLastRead_Response {
        static instance: CPlayer_UpdateSteamAnnouncementLastRead_Response = CPlayer_UpdateSteamAnnouncementLastRead_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetPrivacySettings_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetPrivacySettings_Request {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetPrivacySettings_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetPrivacySettings_Request {
    fn default() -> &'a CPlayer_GetPrivacySettings_Request {
        <CPlayer_GetPrivacySettings_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetPrivacySettings_Request {
    pub fn new() -> CPlayer_GetPrivacySettings_Request {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetPrivacySettings_Request {
    const NAME: &'static str = "CPlayer_GetPrivacySettings_Request";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetPrivacySettings_Request {
        CPlayer_GetPrivacySettings_Request::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetPrivacySettings_Request {
        static instance: CPlayer_GetPrivacySettings_Request = CPlayer_GetPrivacySettings_Request {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPrivacySettings)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPrivacySettings {
    // message fields
    // @@protoc_insertion_point(field:CPrivacySettings.privacy_state)
    pub privacy_state: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CPrivacySettings.privacy_state_inventory)
    pub privacy_state_inventory: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CPrivacySettings.privacy_state_gifts)
    pub privacy_state_gifts: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CPrivacySettings.privacy_state_ownedgames)
    pub privacy_state_ownedgames: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CPrivacySettings.privacy_state_playtime)
    pub privacy_state_playtime: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CPrivacySettings.privacy_state_friendslist)
    pub privacy_state_friendslist: ::std::option::Option<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPrivacySettings.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPrivacySettings {
    fn default() -> &'a CPrivacySettings {
        <CPrivacySettings as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPrivacySettings {
    pub fn new() -> CPrivacySettings {
        ::std::default::Default::default()
    }

    // optional int32 privacy_state = 1;

    pub fn privacy_state(&self) -> i32 {
        self.privacy_state.unwrap_or(0)
    }

    pub fn clear_privacy_state(&mut self) {
        self.privacy_state = ::std::option::Option::None;
    }

    pub fn has_privacy_state(&self) -> bool {
        self.privacy_state.is_some()
    }

    // Param is passed by value, moved
    pub fn set_privacy_state(&mut self, v: i32) {
        self.privacy_state = ::std::option::Option::Some(v);
    }

    // optional int32 privacy_state_inventory = 2;

    pub fn privacy_state_inventory(&self) -> i32 {
        self.privacy_state_inventory.unwrap_or(0)
    }

    pub fn clear_privacy_state_inventory(&mut self) {
        self.privacy_state_inventory = ::std::option::Option::None;
    }

    pub fn has_privacy_state_inventory(&self) -> bool {
        self.privacy_state_inventory.is_some()
    }

    // Param is passed by value, moved
    pub fn set_privacy_state_inventory(&mut self, v: i32) {
        self.privacy_state_inventory = ::std::option::Option::Some(v);
    }

    // optional int32 privacy_state_gifts = 3;

    pub fn privacy_state_gifts(&self) -> i32 {
        self.privacy_state_gifts.unwrap_or(0)
    }

    pub fn clear_privacy_state_gifts(&mut self) {
        self.privacy_state_gifts = ::std::option::Option::None;
    }

    pub fn has_privacy_state_gifts(&self) -> bool {
        self.privacy_state_gifts.is_some()
    }

    // Param is passed by value, moved
    pub fn set_privacy_state_gifts(&mut self, v: i32) {
        self.privacy_state_gifts = ::std::option::Option::Some(v);
    }

    // optional int32 privacy_state_ownedgames = 4;

    pub fn privacy_state_ownedgames(&self) -> i32 {
        self.privacy_state_ownedgames.unwrap_or(0)
    }

    pub fn clear_privacy_state_ownedgames(&mut self) {
        self.privacy_state_ownedgames = ::std::option::Option::None;
    }

    pub fn has_privacy_state_ownedgames(&self) -> bool {
        self.privacy_state_ownedgames.is_some()
    }

    // Param is passed by value, moved
    pub fn set_privacy_state_ownedgames(&mut self, v: i32) {
        self.privacy_state_ownedgames = ::std::option::Option::Some(v);
    }

    // optional int32 privacy_state_playtime = 5;

    pub fn privacy_state_playtime(&self) -> i32 {
        self.privacy_state_playtime.unwrap_or(0)
    }

    pub fn clear_privacy_state_playtime(&mut self) {
        self.privacy_state_playtime = ::std::option::Option::None;
    }

    pub fn has_privacy_state_playtime(&self) -> bool {
        self.privacy_state_playtime.is_some()
    }

    // Param is passed by value, moved
    pub fn set_privacy_state_playtime(&mut self, v: i32) {
        self.privacy_state_playtime = ::std::option::Option::Some(v);
    }

    // optional int32 privacy_state_friendslist = 6;

    pub fn privacy_state_friendslist(&self) -> i32 {
        self.privacy_state_friendslist.unwrap_or(0)
    }

    pub fn clear_privacy_state_friendslist(&mut self) {
        self.privacy_state_friendslist = ::std::option::Option::None;
    }

    pub fn has_privacy_state_friendslist(&self) -> bool {
        self.privacy_state_friendslist.is_some()
    }

    // Param is passed by value, moved
    pub fn set_privacy_state_friendslist(&mut self, v: i32) {
        self.privacy_state_friendslist = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPrivacySettings {
    const NAME: &'static str = "CPrivacySettings";

    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.privacy_state = ::std::option::Option::Some(is.read_int32()?);
                },
                16 => {
                    self.privacy_state_inventory = ::std::option::Option::Some(is.read_int32()?);
                },
                24 => {
                    self.privacy_state_gifts = ::std::option::Option::Some(is.read_int32()?);
                },
                32 => {
                    self.privacy_state_ownedgames = ::std::option::Option::Some(is.read_int32()?);
                },
                40 => {
                    self.privacy_state_playtime = ::std::option::Option::Some(is.read_int32()?);
                },
                48 => {
                    self.privacy_state_friendslist = ::std::option::Option::Some(is.read_int32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.privacy_state {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
        }
        if let Some(v) = self.privacy_state_inventory {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
        }
        if let Some(v) = self.privacy_state_gifts {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v);
        }
        if let Some(v) = self.privacy_state_ownedgames {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v);
        }
        if let Some(v) = self.privacy_state_playtime {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v);
        }
        if let Some(v) = self.privacy_state_friendslist {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(6, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.privacy_state {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.privacy_state_inventory {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.privacy_state_gifts {
            os.write_int32(3, v)?;
        }
        if let Some(v) = self.privacy_state_ownedgames {
            os.write_int32(4, v)?;
        }
        if let Some(v) = self.privacy_state_playtime {
            os.write_int32(5, v)?;
        }
        if let Some(v) = self.privacy_state_friendslist {
            os.write_int32(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() -> CPrivacySettings {
        CPrivacySettings::new()
    }

    fn clear(&mut self) {
        self.privacy_state = ::std::option::Option::None;
        self.privacy_state_inventory = ::std::option::Option::None;
        self.privacy_state_gifts = ::std::option::Option::None;
        self.privacy_state_ownedgames = ::std::option::Option::None;
        self.privacy_state_playtime = ::std::option::Option::None;
        self.privacy_state_friendslist = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPrivacySettings {
        static instance: CPrivacySettings = CPrivacySettings {
            privacy_state: ::std::option::Option::None,
            privacy_state_inventory: ::std::option::Option::None,
            privacy_state_gifts: ::std::option::Option::None,
            privacy_state_ownedgames: ::std::option::Option::None,
            privacy_state_playtime: ::std::option::Option::None,
            privacy_state_friendslist: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetPrivacySettings_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetPrivacySettings_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetPrivacySettings_Response.privacy_settings)
    pub privacy_settings: ::steam_vent_proto_common::protobuf::MessageField<CPrivacySettings>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetPrivacySettings_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetPrivacySettings_Response {
    fn default() -> &'a CPlayer_GetPrivacySettings_Response {
        <CPlayer_GetPrivacySettings_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetPrivacySettings_Response {
    pub fn new() -> CPlayer_GetPrivacySettings_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetPrivacySettings_Response {
    const NAME: &'static str = "CPlayer_GetPrivacySettings_Response";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.privacy_settings)?;
                },
                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.privacy_settings.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.privacy_settings.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetPrivacySettings_Response {
        CPlayer_GetPrivacySettings_Response::new()
    }

    fn clear(&mut self) {
        self.privacy_settings.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetPrivacySettings_Response {
        static instance: CPlayer_GetPrivacySettings_Response = CPlayer_GetPrivacySettings_Response {
            privacy_settings: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetDurationControl_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetDurationControl_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetDurationControl_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetDurationControl_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetDurationControl_Request {
    fn default() -> &'a CPlayer_GetDurationControl_Request {
        <CPlayer_GetDurationControl_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetDurationControl_Request {
    pub fn new() -> CPlayer_GetDurationControl_Request {
        ::std::default::Default::default()
    }

    // optional uint32 appid = 1;

    pub fn appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }

    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

    pub fn has_appid(&self) -> bool {
        self.appid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_appid(&mut self, v: u32) {
        self.appid = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetDurationControl_Request {
    const NAME: &'static str = "CPlayer_GetDurationControl_Request";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_GetDurationControl_Request {
        CPlayer_GetDurationControl_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetDurationControl_Request {
        static instance: CPlayer_GetDurationControl_Request = CPlayer_GetDurationControl_Request {
            appid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_GetDurationControl_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_GetDurationControl_Response {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_GetDurationControl_Response.is_enabled)
    pub is_enabled: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CPlayer_GetDurationControl_Response.seconds)
    pub seconds: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CPlayer_GetDurationControl_Response.seconds_today)
    pub seconds_today: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CPlayer_GetDurationControl_Response.is_steamchina_account)
    pub is_steamchina_account: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CPlayer_GetDurationControl_Response.is_age_verified)
    pub is_age_verified: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CPlayer_GetDurationControl_Response.seconds_allowed_today)
    pub seconds_allowed_today: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_GetDurationControl_Response.age_verification_pending)
    pub age_verification_pending: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CPlayer_GetDurationControl_Response.block_minors)
    pub block_minors: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_GetDurationControl_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_GetDurationControl_Response {
    fn default() -> &'a CPlayer_GetDurationControl_Response {
        <CPlayer_GetDurationControl_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_GetDurationControl_Response {
    pub fn new() -> CPlayer_GetDurationControl_Response {
        ::std::default::Default::default()
    }

    // optional bool is_enabled = 1;

    pub fn is_enabled(&self) -> bool {
        self.is_enabled.unwrap_or(false)
    }

    pub fn clear_is_enabled(&mut self) {
        self.is_enabled = ::std::option::Option::None;
    }

    pub fn has_is_enabled(&self) -> bool {
        self.is_enabled.is_some()
    }

    // Param is passed by value, moved
    pub fn set_is_enabled(&mut self, v: bool) {
        self.is_enabled = ::std::option::Option::Some(v);
    }

    // optional int32 seconds = 2;

    pub fn seconds(&self) -> i32 {
        self.seconds.unwrap_or(0)
    }

    pub fn clear_seconds(&mut self) {
        self.seconds = ::std::option::Option::None;
    }

    pub fn has_seconds(&self) -> bool {
        self.seconds.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seconds(&mut self, v: i32) {
        self.seconds = ::std::option::Option::Some(v);
    }

    // optional int32 seconds_today = 3;

    pub fn seconds_today(&self) -> i32 {
        self.seconds_today.unwrap_or(0)
    }

    pub fn clear_seconds_today(&mut self) {
        self.seconds_today = ::std::option::Option::None;
    }

    pub fn has_seconds_today(&self) -> bool {
        self.seconds_today.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seconds_today(&mut self, v: i32) {
        self.seconds_today = ::std::option::Option::Some(v);
    }

    // optional bool is_steamchina_account = 4;

    pub fn is_steamchina_account(&self) -> bool {
        self.is_steamchina_account.unwrap_or(false)
    }

    pub fn clear_is_steamchina_account(&mut self) {
        self.is_steamchina_account = ::std::option::Option::None;
    }

    pub fn has_is_steamchina_account(&self) -> bool {
        self.is_steamchina_account.is_some()
    }

    // Param is passed by value, moved
    pub fn set_is_steamchina_account(&mut self, v: bool) {
        self.is_steamchina_account = ::std::option::Option::Some(v);
    }

    // optional bool is_age_verified = 5;

    pub fn is_age_verified(&self) -> bool {
        self.is_age_verified.unwrap_or(false)
    }

    pub fn clear_is_age_verified(&mut self) {
        self.is_age_verified = ::std::option::Option::None;
    }

    pub fn has_is_age_verified(&self) -> bool {
        self.is_age_verified.is_some()
    }

    // Param is passed by value, moved
    pub fn set_is_age_verified(&mut self, v: bool) {
        self.is_age_verified = ::std::option::Option::Some(v);
    }

    // optional uint32 seconds_allowed_today = 6;

    pub fn seconds_allowed_today(&self) -> u32 {
        self.seconds_allowed_today.unwrap_or(0)
    }

    pub fn clear_seconds_allowed_today(&mut self) {
        self.seconds_allowed_today = ::std::option::Option::None;
    }

    pub fn has_seconds_allowed_today(&self) -> bool {
        self.seconds_allowed_today.is_some()
    }

    // Param is passed by value, moved
    pub fn set_seconds_allowed_today(&mut self, v: u32) {
        self.seconds_allowed_today = ::std::option::Option::Some(v);
    }

    // optional bool age_verification_pending = 7;

    pub fn age_verification_pending(&self) -> bool {
        self.age_verification_pending.unwrap_or(false)
    }

    pub fn clear_age_verification_pending(&mut self) {
        self.age_verification_pending = ::std::option::Option::None;
    }

    pub fn has_age_verification_pending(&self) -> bool {
        self.age_verification_pending.is_some()
    }

    // Param is passed by value, moved
    pub fn set_age_verification_pending(&mut self, v: bool) {
        self.age_verification_pending = ::std::option::Option::Some(v);
    }

    // optional bool block_minors = 8;

    pub fn block_minors(&self) -> bool {
        self.block_minors.unwrap_or(false)
    }

    pub fn clear_block_minors(&mut self) {
        self.block_minors = ::std::option::Option::None;
    }

    pub fn has_block_minors(&self) -> bool {
        self.block_minors.is_some()
    }

    // Param is passed by value, moved
    pub fn set_block_minors(&mut self, v: bool) {
        self.block_minors = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_GetDurationControl_Response {
    const NAME: &'static str = "CPlayer_GetDurationControl_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.is_enabled = ::std::option::Option::Some(is.read_bool()?);
                },
                16 => {
                    self.seconds = ::std::option::Option::Some(is.read_int32()?);
                },
                24 => {
                    self.seconds_today = ::std::option::Option::Some(is.read_int32()?);
                },
                32 => {
                    self.is_steamchina_account = ::std::option::Option::Some(is.read_bool()?);
                },
                40 => {
                    self.is_age_verified = ::std::option::Option::Some(is.read_bool()?);
                },
                48 => {
                    self.seconds_allowed_today = ::std::option::Option::Some(is.read_uint32()?);
                },
                56 => {
                    self.age_verification_pending = ::std::option::Option::Some(is.read_bool()?);
                },
                64 => {
                    self.block_minors = ::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.is_enabled {
            my_size += 1 + 1;
        }
        if let Some(v) = self.seconds {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
        }
        if let Some(v) = self.seconds_today {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v);
        }
        if let Some(v) = self.is_steamchina_account {
            my_size += 1 + 1;
        }
        if let Some(v) = self.is_age_verified {
            my_size += 1 + 1;
        }
        if let Some(v) = self.seconds_allowed_today {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.age_verification_pending {
            my_size += 1 + 1;
        }
        if let Some(v) = self.block_minors {
            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.is_enabled {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.seconds {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.seconds_today {
            os.write_int32(3, v)?;
        }
        if let Some(v) = self.is_steamchina_account {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.is_age_verified {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.seconds_allowed_today {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.age_verification_pending {
            os.write_bool(7, v)?;
        }
        if let Some(v) = self.block_minors {
            os.write_bool(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() -> CPlayer_GetDurationControl_Response {
        CPlayer_GetDurationControl_Response::new()
    }

    fn clear(&mut self) {
        self.is_enabled = ::std::option::Option::None;
        self.seconds = ::std::option::Option::None;
        self.seconds_today = ::std::option::Option::None;
        self.is_steamchina_account = ::std::option::Option::None;
        self.is_age_verified = ::std::option::Option::None;
        self.seconds_allowed_today = ::std::option::Option::None;
        self.age_verification_pending = ::std::option::Option::None;
        self.block_minors = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_GetDurationControl_Response {
        static instance: CPlayer_GetDurationControl_Response = CPlayer_GetDurationControl_Response {
            is_enabled: ::std::option::Option::None,
            seconds: ::std::option::Option::None,
            seconds_today: ::std::option::Option::None,
            is_steamchina_account: ::std::option::Option::None,
            is_age_verified: ::std::option::Option::None,
            seconds_allowed_today: ::std::option::Option::None,
            age_verification_pending: ::std::option::Option::None,
            block_minors: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_RecordDisconnectedPlaytime_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_RecordDisconnectedPlaytime_Request {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_RecordDisconnectedPlaytime_Request.play_sessions)
    pub play_sessions: ::std::vec::Vec<cplayer_record_disconnected_playtime_request::PlayHistory>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_RecordDisconnectedPlaytime_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_RecordDisconnectedPlaytime_Request {
    fn default() -> &'a CPlayer_RecordDisconnectedPlaytime_Request {
        <CPlayer_RecordDisconnectedPlaytime_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_RecordDisconnectedPlaytime_Request {
    pub fn new() -> CPlayer_RecordDisconnectedPlaytime_Request {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_RecordDisconnectedPlaytime_Request {
    const NAME: &'static str = "CPlayer_RecordDisconnectedPlaytime_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 {
                26 => {
                    self.play_sessions.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.play_sessions {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.play_sessions {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_RecordDisconnectedPlaytime_Request {
        CPlayer_RecordDisconnectedPlaytime_Request::new()
    }

    fn clear(&mut self) {
        self.play_sessions.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_RecordDisconnectedPlaytime_Request {
        static instance: CPlayer_RecordDisconnectedPlaytime_Request = CPlayer_RecordDisconnectedPlaytime_Request {
            play_sessions: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CPlayer_RecordDisconnectedPlaytime_Request`
pub mod cplayer_record_disconnected_playtime_request {
    // @@protoc_insertion_point(message:CPlayer_RecordDisconnectedPlaytime_Request.PlayHistory)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct PlayHistory {
        // message fields
        // @@protoc_insertion_point(field:CPlayer_RecordDisconnectedPlaytime_Request.PlayHistory.appid)
        pub appid: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_RecordDisconnectedPlaytime_Request.PlayHistory.session_time_start)
        pub session_time_start: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_RecordDisconnectedPlaytime_Request.PlayHistory.seconds)
        pub seconds: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CPlayer_RecordDisconnectedPlaytime_Request.PlayHistory.offline)
        pub offline: ::std::option::Option<bool>,
        // @@protoc_insertion_point(field:CPlayer_RecordDisconnectedPlaytime_Request.PlayHistory.owner)
        pub owner: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CPlayer_RecordDisconnectedPlaytime_Request.PlayHistory.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

    impl<'a> ::std::default::Default for &'a PlayHistory {
        fn default() -> &'a PlayHistory {
            <PlayHistory as ::steam_vent_proto_common::protobuf::Message>::default_instance()
        }
    }

    impl PlayHistory {
        pub fn new() -> PlayHistory {
            ::std::default::Default::default()
        }

        // optional uint32 appid = 1;

        pub fn appid(&self) -> u32 {
            self.appid.unwrap_or(0)
        }

        pub fn clear_appid(&mut self) {
            self.appid = ::std::option::Option::None;
        }

        pub fn has_appid(&self) -> bool {
            self.appid.is_some()
        }

        // Param is passed by value, moved
        pub fn set_appid(&mut self, v: u32) {
            self.appid = ::std::option::Option::Some(v);
        }

        // optional uint32 session_time_start = 2;

        pub fn session_time_start(&self) -> u32 {
            self.session_time_start.unwrap_or(0)
        }

        pub fn clear_session_time_start(&mut self) {
            self.session_time_start = ::std::option::Option::None;
        }

        pub fn has_session_time_start(&self) -> bool {
            self.session_time_start.is_some()
        }

        // Param is passed by value, moved
        pub fn set_session_time_start(&mut self, v: u32) {
            self.session_time_start = ::std::option::Option::Some(v);
        }

        // optional uint32 seconds = 3;

        pub fn seconds(&self) -> u32 {
            self.seconds.unwrap_or(0)
        }

        pub fn clear_seconds(&mut self) {
            self.seconds = ::std::option::Option::None;
        }

        pub fn has_seconds(&self) -> bool {
            self.seconds.is_some()
        }

        // Param is passed by value, moved
        pub fn set_seconds(&mut self, v: u32) {
            self.seconds = ::std::option::Option::Some(v);
        }

        // optional bool offline = 4;

        pub fn offline(&self) -> bool {
            self.offline.unwrap_or(false)
        }

        pub fn clear_offline(&mut self) {
            self.offline = ::std::option::Option::None;
        }

        pub fn has_offline(&self) -> bool {
            self.offline.is_some()
        }

        // Param is passed by value, moved
        pub fn set_offline(&mut self, v: bool) {
            self.offline = ::std::option::Option::Some(v);
        }

        // optional uint32 owner = 5;

        pub fn owner(&self) -> u32 {
            self.owner.unwrap_or(0)
        }

        pub fn clear_owner(&mut self) {
            self.owner = ::std::option::Option::None;
        }

        pub fn has_owner(&self) -> bool {
            self.owner.is_some()
        }

        // Param is passed by value, moved
        pub fn set_owner(&mut self, v: u32) {
            self.owner = ::std::option::Option::Some(v);
        }
    }

    impl ::steam_vent_proto_common::protobuf::Message for PlayHistory {
        const NAME: &'static str = "PlayHistory";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.appid = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    16 => {
                        self.session_time_start = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    24 => {
                        self.seconds = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    32 => {
                        self.offline = ::std::option::Option::Some(is.read_bool()?);
                    },
                    40 => {
                        self.owner = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if let Some(v) = self.appid {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
            }
            if let Some(v) = self.session_time_start {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
            }
            if let Some(v) = self.seconds {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
            }
            if let Some(v) = self.offline {
                my_size += 1 + 1;
            }
            if let Some(v) = self.owner {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.appid {
                os.write_uint32(1, v)?;
            }
            if let Some(v) = self.session_time_start {
                os.write_uint32(2, v)?;
            }
            if let Some(v) = self.seconds {
                os.write_uint32(3, v)?;
            }
            if let Some(v) = self.offline {
                os.write_bool(4, v)?;
            }
            if let Some(v) = self.owner {
                os.write_uint32(5, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
            &mut self.special_fields
        }

        fn new() -> PlayHistory {
            PlayHistory::new()
        }

        fn clear(&mut self) {
            self.appid = ::std::option::Option::None;
            self.session_time_start = ::std::option::Option::None;
            self.seconds = ::std::option::Option::None;
            self.offline = ::std::option::Option::None;
            self.owner = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static PlayHistory {
            static instance: PlayHistory = PlayHistory {
                appid: ::std::option::Option::None,
                session_time_start: ::std::option::Option::None,
                seconds: ::std::option::Option::None,
                offline: ::std::option::Option::None,
                owner: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CPlayer_RecordDisconnectedPlaytime_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_RecordDisconnectedPlaytime_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_RecordDisconnectedPlaytime_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_RecordDisconnectedPlaytime_Response {
    fn default() -> &'a CPlayer_RecordDisconnectedPlaytime_Response {
        <CPlayer_RecordDisconnectedPlaytime_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_RecordDisconnectedPlaytime_Response {
    pub fn new() -> CPlayer_RecordDisconnectedPlaytime_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_RecordDisconnectedPlaytime_Response {
    const NAME: &'static str = "CPlayer_RecordDisconnectedPlaytime_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() -> CPlayer_RecordDisconnectedPlaytime_Response {
        CPlayer_RecordDisconnectedPlaytime_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_RecordDisconnectedPlaytime_Response {
        static instance: CPlayer_RecordDisconnectedPlaytime_Response = CPlayer_RecordDisconnectedPlaytime_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_LastPlayedTimes_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_LastPlayedTimes_Notification {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_LastPlayedTimes_Notification.games)
    pub games: ::std::vec::Vec<cplayer_get_last_played_times_response::Game>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_LastPlayedTimes_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_LastPlayedTimes_Notification {
    fn default() -> &'a CPlayer_LastPlayedTimes_Notification {
        <CPlayer_LastPlayedTimes_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_LastPlayedTimes_Notification {
    pub fn new() -> CPlayer_LastPlayedTimes_Notification {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_LastPlayedTimes_Notification {
    const NAME: &'static str = "CPlayer_LastPlayedTimes_Notification";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.games.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.games {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.games {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_LastPlayedTimes_Notification {
        CPlayer_LastPlayedTimes_Notification::new()
    }

    fn clear(&mut self) {
        self.games.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_LastPlayedTimes_Notification {
        static instance: CPlayer_LastPlayedTimes_Notification = CPlayer_LastPlayedTimes_Notification {
            games: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_FriendNicknameChanged_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_FriendNicknameChanged_Notification {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_FriendNicknameChanged_Notification.accountid)
    pub accountid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_FriendNicknameChanged_Notification.nickname)
    pub nickname: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CPlayer_FriendNicknameChanged_Notification.is_echo_to_self)
    pub is_echo_to_self: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_FriendNicknameChanged_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_FriendNicknameChanged_Notification {
    fn default() -> &'a CPlayer_FriendNicknameChanged_Notification {
        <CPlayer_FriendNicknameChanged_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_FriendNicknameChanged_Notification {
    pub fn new() -> CPlayer_FriendNicknameChanged_Notification {
        ::std::default::Default::default()
    }

    // optional fixed32 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 string nickname = 2;

    pub fn nickname(&self) -> &str {
        match self.nickname.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_nickname(&mut self) {
        self.nickname = ::std::option::Option::None;
    }

    pub fn has_nickname(&self) -> bool {
        self.nickname.is_some()
    }

    // Param is passed by value, moved
    pub fn set_nickname(&mut self, v: ::std::string::String) {
        self.nickname = ::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_nickname(&mut self) -> &mut ::std::string::String {
        if self.nickname.is_none() {
            self.nickname = ::std::option::Option::Some(::std::string::String::new());
        }
        self.nickname.as_mut().unwrap()
    }

    // Take field
    pub fn take_nickname(&mut self) -> ::std::string::String {
        self.nickname.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional bool is_echo_to_self = 3;

    pub fn is_echo_to_self(&self) -> bool {
        self.is_echo_to_self.unwrap_or(false)
    }

    pub fn clear_is_echo_to_self(&mut self) {
        self.is_echo_to_self = ::std::option::Option::None;
    }

    pub fn has_is_echo_to_self(&self) -> bool {
        self.is_echo_to_self.is_some()
    }

    // Param is passed by value, moved
    pub fn set_is_echo_to_self(&mut self, v: bool) {
        self.is_echo_to_self = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_FriendNicknameChanged_Notification {
    const NAME: &'static str = "CPlayer_FriendNicknameChanged_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 {
                13 => {
                    self.accountid = ::std::option::Option::Some(is.read_fixed32()?);
                },
                18 => {
                    self.nickname = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.is_echo_to_self = ::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.accountid {
            my_size += 1 + 4;
        }
        if let Some(v) = self.nickname.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.is_echo_to_self {
            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.accountid {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.nickname.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.is_echo_to_self {
            os.write_bool(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() -> CPlayer_FriendNicknameChanged_Notification {
        CPlayer_FriendNicknameChanged_Notification::new()
    }

    fn clear(&mut self) {
        self.accountid = ::std::option::Option::None;
        self.nickname = ::std::option::Option::None;
        self.is_echo_to_self = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_FriendNicknameChanged_Notification {
        static instance: CPlayer_FriendNicknameChanged_Notification = CPlayer_FriendNicknameChanged_Notification {
            accountid: ::std::option::Option::None,
            nickname: ::std::option::Option::None,
            is_echo_to_self: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_FriendEquippedProfileItemsChanged_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_FriendEquippedProfileItemsChanged_Notification {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_FriendEquippedProfileItemsChanged_Notification.accountid)
    pub accountid: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_FriendEquippedProfileItemsChanged_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_FriendEquippedProfileItemsChanged_Notification {
    fn default() -> &'a CPlayer_FriendEquippedProfileItemsChanged_Notification {
        <CPlayer_FriendEquippedProfileItemsChanged_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_FriendEquippedProfileItemsChanged_Notification {
    pub fn new() -> CPlayer_FriendEquippedProfileItemsChanged_Notification {
        ::std::default::Default::default()
    }

    // optional fixed32 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);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_FriendEquippedProfileItemsChanged_Notification {
    const NAME: &'static str = "CPlayer_FriendEquippedProfileItemsChanged_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 {
                13 => {
                    self.accountid = ::std::option::Option::Some(is.read_fixed32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.accountid {
            my_size += 1 + 4;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.accountid {
            os.write_fixed32(1, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_FriendEquippedProfileItemsChanged_Notification {
        CPlayer_FriendEquippedProfileItemsChanged_Notification::new()
    }

    fn clear(&mut self) {
        self.accountid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_FriendEquippedProfileItemsChanged_Notification {
        static instance: CPlayer_FriendEquippedProfileItemsChanged_Notification = CPlayer_FriendEquippedProfileItemsChanged_Notification {
            accountid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_NewSteamAnnouncementState_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_NewSteamAnnouncementState_Notification {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_NewSteamAnnouncementState_Notification.state)
    pub state: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::enums::ENewSteamAnnouncementState>>,
    // @@protoc_insertion_point(field:CPlayer_NewSteamAnnouncementState_Notification.announcement_headline)
    pub announcement_headline: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CPlayer_NewSteamAnnouncementState_Notification.announcement_url)
    pub announcement_url: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CPlayer_NewSteamAnnouncementState_Notification.time_posted)
    pub time_posted: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_NewSteamAnnouncementState_Notification.announcement_gid)
    pub announcement_gid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_NewSteamAnnouncementState_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_NewSteamAnnouncementState_Notification {
    fn default() -> &'a CPlayer_NewSteamAnnouncementState_Notification {
        <CPlayer_NewSteamAnnouncementState_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_NewSteamAnnouncementState_Notification {
    pub fn new() -> CPlayer_NewSteamAnnouncementState_Notification {
        ::std::default::Default::default()
    }

    // optional .ENewSteamAnnouncementState state = 1;

    pub fn state(&self) -> super::enums::ENewSteamAnnouncementState {
        match self.state {
            Some(e) => e.enum_value_or(super::enums::ENewSteamAnnouncementState::k_ENewSteamAnnouncementState_Invalid),
            None => super::enums::ENewSteamAnnouncementState::k_ENewSteamAnnouncementState_Invalid,
        }
    }

    pub fn clear_state(&mut self) {
        self.state = ::std::option::Option::None;
    }

    pub fn has_state(&self) -> bool {
        self.state.is_some()
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: super::enums::ENewSteamAnnouncementState) {
        self.state = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional string announcement_headline = 2;

    pub fn announcement_headline(&self) -> &str {
        match self.announcement_headline.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_announcement_headline(&mut self) {
        self.announcement_headline = ::std::option::Option::None;
    }

    pub fn has_announcement_headline(&self) -> bool {
        self.announcement_headline.is_some()
    }

    // Param is passed by value, moved
    pub fn set_announcement_headline(&mut self, v: ::std::string::String) {
        self.announcement_headline = ::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_announcement_headline(&mut self) -> &mut ::std::string::String {
        if self.announcement_headline.is_none() {
            self.announcement_headline = ::std::option::Option::Some(::std::string::String::new());
        }
        self.announcement_headline.as_mut().unwrap()
    }

    // Take field
    pub fn take_announcement_headline(&mut self) -> ::std::string::String {
        self.announcement_headline.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string announcement_url = 3;

    pub fn announcement_url(&self) -> &str {
        match self.announcement_url.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_announcement_url(&mut self) {
        self.announcement_url = ::std::option::Option::None;
    }

    pub fn has_announcement_url(&self) -> bool {
        self.announcement_url.is_some()
    }

    // Param is passed by value, moved
    pub fn set_announcement_url(&mut self, v: ::std::string::String) {
        self.announcement_url = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_announcement_url(&mut self) -> &mut ::std::string::String {
        if self.announcement_url.is_none() {
            self.announcement_url = ::std::option::Option::Some(::std::string::String::new());
        }
        self.announcement_url.as_mut().unwrap()
    }

    // Take field
    pub fn take_announcement_url(&mut self) -> ::std::string::String {
        self.announcement_url.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional uint32 time_posted = 4;

    pub fn time_posted(&self) -> u32 {
        self.time_posted.unwrap_or(0)
    }

    pub fn clear_time_posted(&mut self) {
        self.time_posted = ::std::option::Option::None;
    }

    pub fn has_time_posted(&self) -> bool {
        self.time_posted.is_some()
    }

    // Param is passed by value, moved
    pub fn set_time_posted(&mut self, v: u32) {
        self.time_posted = ::std::option::Option::Some(v);
    }

    // optional uint64 announcement_gid = 5;

    pub fn announcement_gid(&self) -> u64 {
        self.announcement_gid.unwrap_or(0)
    }

    pub fn clear_announcement_gid(&mut self) {
        self.announcement_gid = ::std::option::Option::None;
    }

    pub fn has_announcement_gid(&self) -> bool {
        self.announcement_gid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_announcement_gid(&mut self, v: u64) {
        self.announcement_gid = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_NewSteamAnnouncementState_Notification {
    const NAME: &'static str = "CPlayer_NewSteamAnnouncementState_Notification";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.state = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                18 => {
                    self.announcement_headline = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    self.announcement_url = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.time_posted = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.announcement_gid = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.state {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v.value());
        }
        if let Some(v) = self.announcement_headline.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.announcement_url.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.time_posted {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.announcement_gid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(5, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.state {
            os.write_enum(1, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.announcement_headline.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.announcement_url.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.time_posted {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.announcement_gid {
            os.write_uint64(5, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_NewSteamAnnouncementState_Notification {
        CPlayer_NewSteamAnnouncementState_Notification::new()
    }

    fn clear(&mut self) {
        self.state = ::std::option::Option::None;
        self.announcement_headline = ::std::option::Option::None;
        self.announcement_url = ::std::option::Option::None;
        self.time_posted = ::std::option::Option::None;
        self.announcement_gid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_NewSteamAnnouncementState_Notification {
        static instance: CPlayer_NewSteamAnnouncementState_Notification = CPlayer_NewSteamAnnouncementState_Notification {
            state: ::std::option::Option::None,
            announcement_headline: ::std::option::Option::None,
            announcement_url: ::std::option::Option::None,
            time_posted: ::std::option::Option::None,
            announcement_gid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_CommunityPreferencesChanged_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_CommunityPreferencesChanged_Notification {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_CommunityPreferencesChanged_Notification.preferences)
    pub preferences: ::steam_vent_proto_common::protobuf::MessageField<CPlayer_CommunityPreferences>,
    // @@protoc_insertion_point(field:CPlayer_CommunityPreferencesChanged_Notification.content_descriptor_preferences)
    pub content_descriptor_preferences: ::steam_vent_proto_common::protobuf::MessageField<super::steammessages_base::UserContentDescriptorPreferences>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_CommunityPreferencesChanged_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_CommunityPreferencesChanged_Notification {
    fn default() -> &'a CPlayer_CommunityPreferencesChanged_Notification {
        <CPlayer_CommunityPreferencesChanged_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_CommunityPreferencesChanged_Notification {
    pub fn new() -> CPlayer_CommunityPreferencesChanged_Notification {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_CommunityPreferencesChanged_Notification {
    const NAME: &'static str = "CPlayer_CommunityPreferencesChanged_Notification";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.preferences)?;
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.content_descriptor_preferences)?;
                },
                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.preferences.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.content_descriptor_preferences.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.preferences.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.content_descriptor_preferences.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_CommunityPreferencesChanged_Notification {
        CPlayer_CommunityPreferencesChanged_Notification::new()
    }

    fn clear(&mut self) {
        self.preferences.clear();
        self.content_descriptor_preferences.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_CommunityPreferencesChanged_Notification {
        static instance: CPlayer_CommunityPreferencesChanged_Notification = CPlayer_CommunityPreferencesChanged_Notification {
            preferences: ::steam_vent_proto_common::protobuf::MessageField::none(),
            content_descriptor_preferences: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_TextFilterWordsChanged_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_TextFilterWordsChanged_Notification {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_TextFilterWordsChanged_Notification.words)
    pub words: ::steam_vent_proto_common::protobuf::MessageField<CPlayer_TextFilterWords>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_TextFilterWordsChanged_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_TextFilterWordsChanged_Notification {
    fn default() -> &'a CPlayer_TextFilterWordsChanged_Notification {
        <CPlayer_TextFilterWordsChanged_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_TextFilterWordsChanged_Notification {
    pub fn new() -> CPlayer_TextFilterWordsChanged_Notification {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_TextFilterWordsChanged_Notification {
    const NAME: &'static str = "CPlayer_TextFilterWordsChanged_Notification";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.words)?;
                },
                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.words.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.words.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_TextFilterWordsChanged_Notification {
        CPlayer_TextFilterWordsChanged_Notification::new()
    }

    fn clear(&mut self) {
        self.words.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_TextFilterWordsChanged_Notification {
        static instance: CPlayer_TextFilterWordsChanged_Notification = CPlayer_TextFilterWordsChanged_Notification {
            words: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_PerFriendPreferencesChanged_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_PerFriendPreferencesChanged_Notification {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_PerFriendPreferencesChanged_Notification.accountid)
    pub accountid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CPlayer_PerFriendPreferencesChanged_Notification.preferences)
    pub preferences: ::steam_vent_proto_common::protobuf::MessageField<PerFriendPreferences>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_PerFriendPreferencesChanged_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_PerFriendPreferencesChanged_Notification {
    fn default() -> &'a CPlayer_PerFriendPreferencesChanged_Notification {
        <CPlayer_PerFriendPreferencesChanged_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_PerFriendPreferencesChanged_Notification {
    pub fn new() -> CPlayer_PerFriendPreferencesChanged_Notification {
        ::std::default::Default::default()
    }

    // optional fixed32 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);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_PerFriendPreferencesChanged_Notification {
    const NAME: &'static str = "CPlayer_PerFriendPreferencesChanged_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 {
                13 => {
                    self.accountid = ::std::option::Option::Some(is.read_fixed32()?);
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.preferences)?;
                },
                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 += 1 + 4;
        }
        if let Some(v) = self.preferences.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.accountid {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.preferences.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_PerFriendPreferencesChanged_Notification {
        CPlayer_PerFriendPreferencesChanged_Notification::new()
    }

    fn clear(&mut self) {
        self.accountid = ::std::option::Option::None;
        self.preferences.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_PerFriendPreferencesChanged_Notification {
        static instance: CPlayer_PerFriendPreferencesChanged_Notification = CPlayer_PerFriendPreferencesChanged_Notification {
            accountid: ::std::option::Option::None,
            preferences: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CPlayer_PrivacySettingsChanged_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPlayer_PrivacySettingsChanged_Notification {
    // message fields
    // @@protoc_insertion_point(field:CPlayer_PrivacySettingsChanged_Notification.privacy_settings)
    pub privacy_settings: ::steam_vent_proto_common::protobuf::MessageField<CPrivacySettings>,
    // special fields
    // @@protoc_insertion_point(special_field:CPlayer_PrivacySettingsChanged_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CPlayer_PrivacySettingsChanged_Notification {
    fn default() -> &'a CPlayer_PrivacySettingsChanged_Notification {
        <CPlayer_PrivacySettingsChanged_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CPlayer_PrivacySettingsChanged_Notification {
    pub fn new() -> CPlayer_PrivacySettingsChanged_Notification {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CPlayer_PrivacySettingsChanged_Notification {
    const NAME: &'static str = "CPlayer_PrivacySettingsChanged_Notification";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.privacy_settings)?;
                },
                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.privacy_settings.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.privacy_settings.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CPlayer_PrivacySettingsChanged_Notification {
        CPlayer_PrivacySettingsChanged_Notification::new()
    }

    fn clear(&mut self) {
        self.privacy_settings.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CPlayer_PrivacySettingsChanged_Notification {
        static instance: CPlayer_PrivacySettingsChanged_Notification = CPlayer_PrivacySettingsChanged_Notification {
            privacy_settings: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:EProfileCustomizationStyle)
pub enum EProfileCustomizationStyle {
    // @@protoc_insertion_point(enum_value:EProfileCustomizationStyle.k_EProfileCustomizationStyleDefault)
    k_EProfileCustomizationStyleDefault = 0,
    // @@protoc_insertion_point(enum_value:EProfileCustomizationStyle.k_EProfileCustomizationStyleSelected)
    k_EProfileCustomizationStyleSelected = 1,
    // @@protoc_insertion_point(enum_value:EProfileCustomizationStyle.k_EProfileCustomizationStyleRarest)
    k_EProfileCustomizationStyleRarest = 2,
    // @@protoc_insertion_point(enum_value:EProfileCustomizationStyle.k_EProfileCustomizationStyleMostRecent)
    k_EProfileCustomizationStyleMostRecent = 3,
    // @@protoc_insertion_point(enum_value:EProfileCustomizationStyle.k_EProfileCustomizationStyleRandom)
    k_EProfileCustomizationStyleRandom = 4,
    // @@protoc_insertion_point(enum_value:EProfileCustomizationStyle.k_EProfileCustomizationStyleHighestRated)
    k_EProfileCustomizationStyleHighestRated = 5,
}

impl ::steam_vent_proto_common::protobuf::Enum for EProfileCustomizationStyle {
    const NAME: &'static str = "EProfileCustomizationStyle";

    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<EProfileCustomizationStyle> {
        match value {
            0 => ::std::option::Option::Some(EProfileCustomizationStyle::k_EProfileCustomizationStyleDefault),
            1 => ::std::option::Option::Some(EProfileCustomizationStyle::k_EProfileCustomizationStyleSelected),
            2 => ::std::option::Option::Some(EProfileCustomizationStyle::k_EProfileCustomizationStyleRarest),
            3 => ::std::option::Option::Some(EProfileCustomizationStyle::k_EProfileCustomizationStyleMostRecent),
            4 => ::std::option::Option::Some(EProfileCustomizationStyle::k_EProfileCustomizationStyleRandom),
            5 => ::std::option::Option::Some(EProfileCustomizationStyle::k_EProfileCustomizationStyleHighestRated),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<EProfileCustomizationStyle> {
        match str {
            "k_EProfileCustomizationStyleDefault" => ::std::option::Option::Some(EProfileCustomizationStyle::k_EProfileCustomizationStyleDefault),
            "k_EProfileCustomizationStyleSelected" => ::std::option::Option::Some(EProfileCustomizationStyle::k_EProfileCustomizationStyleSelected),
            "k_EProfileCustomizationStyleRarest" => ::std::option::Option::Some(EProfileCustomizationStyle::k_EProfileCustomizationStyleRarest),
            "k_EProfileCustomizationStyleMostRecent" => ::std::option::Option::Some(EProfileCustomizationStyle::k_EProfileCustomizationStyleMostRecent),
            "k_EProfileCustomizationStyleRandom" => ::std::option::Option::Some(EProfileCustomizationStyle::k_EProfileCustomizationStyleRandom),
            "k_EProfileCustomizationStyleHighestRated" => ::std::option::Option::Some(EProfileCustomizationStyle::k_EProfileCustomizationStyleHighestRated),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [EProfileCustomizationStyle] = &[
        EProfileCustomizationStyle::k_EProfileCustomizationStyleDefault,
        EProfileCustomizationStyle::k_EProfileCustomizationStyleSelected,
        EProfileCustomizationStyle::k_EProfileCustomizationStyleRarest,
        EProfileCustomizationStyle::k_EProfileCustomizationStyleMostRecent,
        EProfileCustomizationStyle::k_EProfileCustomizationStyleRandom,
        EProfileCustomizationStyle::k_EProfileCustomizationStyleHighestRated,
    ];
}

impl ::std::default::Default for EProfileCustomizationStyle {
    fn default() -> Self {
        EProfileCustomizationStyle::k_EProfileCustomizationStyleDefault
    }
}


#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:EAgreementType)
pub enum EAgreementType {
    // @@protoc_insertion_point(enum_value:EAgreementType.k_EAgreementType_Invalid)
    k_EAgreementType_Invalid = -1,
    // @@protoc_insertion_point(enum_value:EAgreementType.k_EAgreementType_GlobalSSA)
    k_EAgreementType_GlobalSSA = 0,
    // @@protoc_insertion_point(enum_value:EAgreementType.k_EAgreementType_ChinaSSA)
    k_EAgreementType_ChinaSSA = 1,
}

impl ::steam_vent_proto_common::protobuf::Enum for EAgreementType {
    const NAME: &'static str = "EAgreementType";

    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<EAgreementType> {
        match value {
            -1 => ::std::option::Option::Some(EAgreementType::k_EAgreementType_Invalid),
            0 => ::std::option::Option::Some(EAgreementType::k_EAgreementType_GlobalSSA),
            1 => ::std::option::Option::Some(EAgreementType::k_EAgreementType_ChinaSSA),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<EAgreementType> {
        match str {
            "k_EAgreementType_Invalid" => ::std::option::Option::Some(EAgreementType::k_EAgreementType_Invalid),
            "k_EAgreementType_GlobalSSA" => ::std::option::Option::Some(EAgreementType::k_EAgreementType_GlobalSSA),
            "k_EAgreementType_ChinaSSA" => ::std::option::Option::Some(EAgreementType::k_EAgreementType_ChinaSSA),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [EAgreementType] = &[
        EAgreementType::k_EAgreementType_Invalid,
        EAgreementType::k_EAgreementType_GlobalSSA,
        EAgreementType::k_EAgreementType_ChinaSSA,
    ];
}

// Note, `Default` is implemented although default value is not 0
impl ::std::default::Default for EAgreementType {
    fn default() -> Self {
        EAgreementType::k_EAgreementType_Invalid
    }
}


#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:ENotificationSetting)
pub enum ENotificationSetting {
    // @@protoc_insertion_point(enum_value:ENotificationSetting.k_ENotificationSettingNotifyUseDefault)
    k_ENotificationSettingNotifyUseDefault = 0,
    // @@protoc_insertion_point(enum_value:ENotificationSetting.k_ENotificationSettingAlways)
    k_ENotificationSettingAlways = 1,
    // @@protoc_insertion_point(enum_value:ENotificationSetting.k_ENotificationSettingNever)
    k_ENotificationSettingNever = 2,
}

impl ::steam_vent_proto_common::protobuf::Enum for ENotificationSetting {
    const NAME: &'static str = "ENotificationSetting";

    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<ENotificationSetting> {
        match value {
            0 => ::std::option::Option::Some(ENotificationSetting::k_ENotificationSettingNotifyUseDefault),
            1 => ::std::option::Option::Some(ENotificationSetting::k_ENotificationSettingAlways),
            2 => ::std::option::Option::Some(ENotificationSetting::k_ENotificationSettingNever),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<ENotificationSetting> {
        match str {
            "k_ENotificationSettingNotifyUseDefault" => ::std::option::Option::Some(ENotificationSetting::k_ENotificationSettingNotifyUseDefault),
            "k_ENotificationSettingAlways" => ::std::option::Option::Some(ENotificationSetting::k_ENotificationSettingAlways),
            "k_ENotificationSettingNever" => ::std::option::Option::Some(ENotificationSetting::k_ENotificationSettingNever),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [ENotificationSetting] = &[
        ENotificationSetting::k_ENotificationSettingNotifyUseDefault,
        ENotificationSetting::k_ENotificationSettingAlways,
        ENotificationSetting::k_ENotificationSettingNever,
    ];
}

impl ::std::default::Default for ENotificationSetting {
    fn default() -> Self {
        ENotificationSetting::k_ENotificationSettingNotifyUseDefault
    }
}


#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:ETextFilterSetting)
pub enum ETextFilterSetting {
    // @@protoc_insertion_point(enum_value:ETextFilterSetting.k_ETextFilterSettingSteamLabOptedOut)
    k_ETextFilterSettingSteamLabOptedOut = 0,
    // @@protoc_insertion_point(enum_value:ETextFilterSetting.k_ETextFilterSettingEnabled)
    k_ETextFilterSettingEnabled = 1,
    // @@protoc_insertion_point(enum_value:ETextFilterSetting.k_ETextFilterSettingEnabledAllowProfanity)
    k_ETextFilterSettingEnabledAllowProfanity = 2,
    // @@protoc_insertion_point(enum_value:ETextFilterSetting.k_ETextFilterSettingDisabled)
    k_ETextFilterSettingDisabled = 3,
}

impl ::steam_vent_proto_common::protobuf::Enum for ETextFilterSetting {
    const NAME: &'static str = "ETextFilterSetting";

    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<ETextFilterSetting> {
        match value {
            0 => ::std::option::Option::Some(ETextFilterSetting::k_ETextFilterSettingSteamLabOptedOut),
            1 => ::std::option::Option::Some(ETextFilterSetting::k_ETextFilterSettingEnabled),
            2 => ::std::option::Option::Some(ETextFilterSetting::k_ETextFilterSettingEnabledAllowProfanity),
            3 => ::std::option::Option::Some(ETextFilterSetting::k_ETextFilterSettingDisabled),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<ETextFilterSetting> {
        match str {
            "k_ETextFilterSettingSteamLabOptedOut" => ::std::option::Option::Some(ETextFilterSetting::k_ETextFilterSettingSteamLabOptedOut),
            "k_ETextFilterSettingEnabled" => ::std::option::Option::Some(ETextFilterSetting::k_ETextFilterSettingEnabled),
            "k_ETextFilterSettingEnabledAllowProfanity" => ::std::option::Option::Some(ETextFilterSetting::k_ETextFilterSettingEnabledAllowProfanity),
            "k_ETextFilterSettingDisabled" => ::std::option::Option::Some(ETextFilterSetting::k_ETextFilterSettingDisabled),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [ETextFilterSetting] = &[
        ETextFilterSetting::k_ETextFilterSettingSteamLabOptedOut,
        ETextFilterSetting::k_ETextFilterSettingEnabled,
        ETextFilterSetting::k_ETextFilterSettingEnabledAllowProfanity,
        ETextFilterSetting::k_ETextFilterSettingDisabled,
    ];
}

impl ::std::default::Default for ETextFilterSetting {
    fn default() -> Self {
        ETextFilterSetting::k_ETextFilterSettingSteamLabOptedOut
    }
}



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 CPlayer_GetRecentPlaytimeSessionsForChild_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 CPlayer_GetRecentPlaytimeSessionsForChild_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 CPlayer_GetPlayerLinkDetails_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 CPlayer_GetPlayerLinkDetails_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 CPlayer_GetMutualFriendsForIncomingInvites_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 CPlayer_IncomingInviteMutualFriendList {
    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 CPlayer_GetMutualFriendsForIncomingInvites_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 CPlayer_GetOwnedGames_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 CPlayer_GetOwnedGames_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 CPlayer_GetPlayNext_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 CPlayer_GetPlayNext_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 CPlayer_GetFriendsGameplayInfo_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 CPlayer_GetFriendsGameplayInfo_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 CPlayer_GetGameBadgeLevels_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 CPlayer_GetGameBadgeLevels_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 CPlayer_GetProfileBackground_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 ProfileItem {
    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 CPlayer_GetProfileBackground_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 CPlayer_SetProfileBackground_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 CPlayer_SetProfileBackground_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 CPlayer_GetMiniProfileBackground_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 CPlayer_GetMiniProfileBackground_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 CPlayer_SetMiniProfileBackground_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 CPlayer_SetMiniProfileBackground_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 CPlayer_GetAvatarFrame_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 CPlayer_GetAvatarFrame_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 CPlayer_SetAvatarFrame_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 CPlayer_SetAvatarFrame_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 CPlayer_GetAnimatedAvatar_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 CPlayer_GetAnimatedAvatar_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 CPlayer_SetAnimatedAvatar_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 CPlayer_SetAnimatedAvatar_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 CPlayer_GetSteamDeckKeyboardSkin_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 CPlayer_GetSteamDeckKeyboardSkin_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 CPlayer_SetSteamDeckKeyboardSkin_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 CPlayer_SetSteamDeckKeyboardSkin_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 CPlayer_GetProfileItemsOwned_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 CPlayer_GetProfileItemsOwned_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 CPlayer_GetProfileItemsEquipped_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 CPlayer_GetProfileItemsEquipped_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 CPlayer_SetEquippedProfileItemFlags_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 CPlayer_SetEquippedProfileItemFlags_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 CPlayer_GetEmoticonList_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 CPlayer_GetEmoticonList_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 CPlayer_GetCommunityBadgeProgress_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 CPlayer_GetCommunityBadgeProgress_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 CPlayer_GetTopAchievementsForGames_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 CPlayer_GetTopAchievementsForGames_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 CPlayer_GetAchievementsProgress_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 CPlayer_GetAchievementsProgress_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 CPlayer_GetGameAchievements_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 CPlayer_GetGameAchievements_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 CPlayer_GetFavoriteBadge_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 CPlayer_GetFavoriteBadge_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 CPlayer_SetFavoriteBadge_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 CPlayer_SetFavoriteBadge_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 CPlayer_GetProfileCustomization_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 ProfileCustomizationSlot {
    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 ProfileCustomization {
    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 ProfileTheme {
    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 ProfilePreferences {
    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 CPlayer_GetProfileCustomization_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 CPlayer_GetPurchasedProfileCustomizations_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 CPlayer_GetPurchasedProfileCustomizations_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 CPlayer_GetPurchasedAndUpgradedProfileCustomizations_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 CPlayer_GetPurchasedAndUpgradedProfileCustomizations_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 CPlayer_GetProfileThemesAvailable_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 CPlayer_GetProfileThemesAvailable_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 CPlayer_SetProfileTheme_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 CPlayer_SetProfileTheme_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 CPlayer_SetProfilePreferences_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 CPlayer_SetProfilePreferences_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 CPlayer_PostStatusToFriends_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 CPlayer_PostStatusToFriends_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 CPlayer_GetPostedStatus_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 CPlayer_GetPostedStatus_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 CPlayer_DeletePostedStatus_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 CPlayer_DeletePostedStatus_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 CPlayer_GetLastPlayedTimes_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 CPlayer_GetLastPlayedTimes_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 CPlayer_GetTimeSSAAccepted_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 CPlayer_GetTimeSSAAccepted_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 CPlayer_AcceptSSA_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 CPlayer_AcceptSSA_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 CPlayer_GetNicknameList_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 CPlayer_GetNicknameList_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 CPlayer_GetPerFriendPreferences_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 PerFriendPreferences {
    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 CPlayer_GetPerFriendPreferences_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 CPlayer_SetPerFriendPreferences_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 CPlayer_SetPerFriendPreferences_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 CPlayer_AddFriend_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 CPlayer_AddFriend_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 CPlayer_RemoveFriend_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 CPlayer_RemoveFriend_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 CPlayer_IgnoreFriend_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 CPlayer_IgnoreFriend_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 CPlayer_GetCommunityPreferences_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 CPlayer_CommunityPreferences {
    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 CPlayer_GetCommunityPreferences_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 CPlayer_SetCommunityPreferences_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 CPlayer_SetCommunityPreferences_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 CPlayer_GetTextFilterWords_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 CPlayer_TextFilterWords {
    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 CPlayer_GetTextFilterWords_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 CPlayer_GetNewSteamAnnouncementState_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 CPlayer_GetNewSteamAnnouncementState_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 CPlayer_UpdateSteamAnnouncementLastRead_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 CPlayer_UpdateSteamAnnouncementLastRead_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 CPlayer_GetPrivacySettings_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 CPrivacySettings {
    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 CPlayer_GetPrivacySettings_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 CPlayer_GetDurationControl_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 CPlayer_GetDurationControl_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 CPlayer_RecordDisconnectedPlaytime_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 CPlayer_RecordDisconnectedPlaytime_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 CPlayer_LastPlayedTimes_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 CPlayer_FriendNicknameChanged_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 CPlayer_FriendEquippedProfileItemsChanged_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 CPlayer_NewSteamAnnouncementState_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 CPlayer_CommunityPreferencesChanged_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 CPlayer_TextFilterWordsChanged_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 CPlayer_PerFriendPreferencesChanged_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 CPlayer_PrivacySettingsChanged_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 Player {}
impl ::steam_vent_proto_common::RpcService for Player {
    const SERVICE_NAME: &'static str = "Player";
}
///
struct PlayerClient {}
impl ::steam_vent_proto_common::RpcService for PlayerClient {
    const SERVICE_NAME: &'static str = "PlayerClient";
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_AcceptSSA_Request {
    const METHOD_NAME: &'static str = "Player.AcceptSSA#1";
    type Response = CPlayer_AcceptSSA_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_AddFriend_Request {
    const METHOD_NAME: &'static str = "Player.AddFriend#1";
    type Response = CPlayer_AddFriend_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_CommunityPreferencesChanged_Notification {
    const METHOD_NAME: &'static str = "PlayerClient.NotifyCommunityPreferencesChanged#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_DeletePostedStatus_Request {
    const METHOD_NAME: &'static str = "Player.DeletePostedStatus#1";
    type Response = CPlayer_DeletePostedStatus_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_FriendEquippedProfileItemsChanged_Notification {
    const METHOD_NAME: &'static str = "PlayerClient.NotifyFriendEquippedProfileItemsChanged#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_FriendNicknameChanged_Notification {
    const METHOD_NAME: &'static str = "PlayerClient.NotifyFriendNicknameChanged#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetAchievementsProgress_Request {
    const METHOD_NAME: &'static str = "Player.GetAchievementsProgress#1";
    type Response = CPlayer_GetAchievementsProgress_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetAnimatedAvatar_Request {
    const METHOD_NAME: &'static str = "Player.GetAnimatedAvatar#1";
    type Response = CPlayer_GetAnimatedAvatar_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetAvatarFrame_Request {
    const METHOD_NAME: &'static str = "Player.GetAvatarFrame#1";
    type Response = CPlayer_GetAvatarFrame_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetCommunityBadgeProgress_Request {
    const METHOD_NAME: &'static str = "Player.GetCommunityBadgeProgress#1";
    type Response = CPlayer_GetCommunityBadgeProgress_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetCommunityPreferences_Request {
    const METHOD_NAME: &'static str = "Player.GetCommunityPreferences#1";
    type Response = CPlayer_GetCommunityPreferences_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetDurationControl_Request {
    const METHOD_NAME: &'static str = "Player.GetDurationControl#1";
    type Response = CPlayer_GetDurationControl_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetEmoticonList_Request {
    const METHOD_NAME: &'static str = "Player.GetEmoticonList#1";
    type Response = CPlayer_GetEmoticonList_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetFavoriteBadge_Request {
    const METHOD_NAME: &'static str = "Player.GetFavoriteBadge#1";
    type Response = CPlayer_GetFavoriteBadge_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetFriendsGameplayInfo_Request {
    const METHOD_NAME: &'static str = "Player.GetFriendsGameplayInfo#1";
    type Response = CPlayer_GetFriendsGameplayInfo_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetGameAchievements_Request {
    const METHOD_NAME: &'static str = "Player.GetGameAchievements#1";
    type Response = CPlayer_GetGameAchievements_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetGameBadgeLevels_Request {
    const METHOD_NAME: &'static str = "Player.GetGameBadgeLevels#1";
    type Response = CPlayer_GetGameBadgeLevels_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetLastPlayedTimes_Request {
    const METHOD_NAME: &'static str = "Player.ClientGetLastPlayedTimes#1";
    type Response = CPlayer_GetLastPlayedTimes_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetMiniProfileBackground_Request {
    const METHOD_NAME: &'static str = "Player.GetMiniProfileBackground#1";
    type Response = CPlayer_GetMiniProfileBackground_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_GetMutualFriendsForIncomingInvites_Request {
    const METHOD_NAME: &'static str = "Player.GetMutualFriendsForIncomingInvites#1";
    type Response = CPlayer_GetMutualFriendsForIncomingInvites_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_GetNewSteamAnnouncementState_Request {
    const METHOD_NAME: &'static str = "Player.GetNewSteamAnnouncementState#1";
    type Response = CPlayer_GetNewSteamAnnouncementState_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetNicknameList_Request {
    const METHOD_NAME: &'static str = "Player.GetNicknameList#1";
    type Response = CPlayer_GetNicknameList_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetOwnedGames_Request {
    const METHOD_NAME: &'static str = "Player.GetOwnedGames#1";
    type Response = CPlayer_GetOwnedGames_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetPerFriendPreferences_Request {
    const METHOD_NAME: &'static str = "Player.GetPerFriendPreferences#1";
    type Response = CPlayer_GetPerFriendPreferences_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetPlayNext_Request {
    const METHOD_NAME: &'static str = "Player.GetPlayNext#1";
    type Response = CPlayer_GetPlayNext_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetPlayerLinkDetails_Request {
    const METHOD_NAME: &'static str = "Player.GetPlayerLinkDetails#1";
    type Response = CPlayer_GetPlayerLinkDetails_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetPostedStatus_Request {
    const METHOD_NAME: &'static str = "Player.GetPostedStatus#1";
    type Response = CPlayer_GetPostedStatus_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetPrivacySettings_Request {
    const METHOD_NAME: &'static str = "Player.GetPrivacySettings#1";
    type Response = CPlayer_GetPrivacySettings_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetProfileBackground_Request {
    const METHOD_NAME: &'static str = "Player.GetProfileBackground#1";
    type Response = CPlayer_GetProfileBackground_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetProfileCustomization_Request {
    const METHOD_NAME: &'static str = "Player.GetProfileCustomization#1";
    type Response = CPlayer_GetProfileCustomization_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetProfileItemsEquipped_Request {
    const METHOD_NAME: &'static str = "Player.GetProfileItemsEquipped#1";
    type Response = CPlayer_GetProfileItemsEquipped_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetProfileItemsOwned_Request {
    const METHOD_NAME: &'static str = "Player.GetProfileItemsOwned#1";
    type Response = CPlayer_GetProfileItemsOwned_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetProfileThemesAvailable_Request {
    const METHOD_NAME: &'static str = "Player.GetProfileThemesAvailable#1";
    type Response = CPlayer_GetProfileThemesAvailable_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Request {
    const METHOD_NAME: &'static str = "Player.GetPurchasedAndUpgradedProfileCustomizations#1";
    type Response = CPlayer_GetPurchasedAndUpgradedProfileCustomizations_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_GetPurchasedProfileCustomizations_Request {
    const METHOD_NAME: &'static str = "Player.GetPurchasedProfileCustomizations#1";
    type Response = CPlayer_GetPurchasedProfileCustomizations_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_GetRecentPlaytimeSessionsForChild_Request {
    const METHOD_NAME: &'static str = "Player.GetRecentPlaytimeSessionsForChild#1";
    type Response = CPlayer_GetRecentPlaytimeSessionsForChild_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetSteamDeckKeyboardSkin_Request {
    const METHOD_NAME: &'static str = "Player.GetSteamDeckKeyboardSkin#1";
    type Response = CPlayer_GetSteamDeckKeyboardSkin_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetTextFilterWords_Request {
    const METHOD_NAME: &'static str = "Player.GetTextFilterWords#1";
    type Response = CPlayer_GetTextFilterWords_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_GetTimeSSAAccepted_Request {
    const METHOD_NAME: &'static str = "Player.GetTimeSSAAccepted#1";
    type Response = CPlayer_GetTimeSSAAccepted_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_GetTopAchievementsForGames_Request {
    const METHOD_NAME: &'static str = "Player.GetTopAchievementsForGames#1";
    type Response = CPlayer_GetTopAchievementsForGames_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_IgnoreFriend_Request {
    const METHOD_NAME: &'static str = "Player.IgnoreFriend#1";
    type Response = CPlayer_IgnoreFriend_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_LastPlayedTimes_Notification {
    const METHOD_NAME: &'static str = "PlayerClient.NotifyLastPlayedTimes#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_NewSteamAnnouncementState_Notification {
    const METHOD_NAME: &'static str = "PlayerClient.NotifyNewSteamAnnouncementState#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_PerFriendPreferencesChanged_Notification {
    const METHOD_NAME: &'static str = "PlayerClient.NotifyPerFriendPreferencesChanged#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_PostStatusToFriends_Request {
    const METHOD_NAME: &'static str = "Player.PostStatusToFriends#1";
    type Response = CPlayer_PostStatusToFriends_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_PrivacySettingsChanged_Notification {
    const METHOD_NAME: &'static str = "PlayerClient.NotifyPrivacyPrivacySettingsChanged#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_RecordDisconnectedPlaytime_Request {
    const METHOD_NAME: &'static str = "Player.RecordDisconnectedPlaytime#1";
    type Response = CPlayer_RecordDisconnectedPlaytime_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_RemoveFriend_Request {
    const METHOD_NAME: &'static str = "Player.RemoveFriend#1";
    type Response = CPlayer_RemoveFriend_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_SetAnimatedAvatar_Request {
    const METHOD_NAME: &'static str = "Player.SetAnimatedAvatar#1";
    type Response = CPlayer_SetAnimatedAvatar_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_SetAvatarFrame_Request {
    const METHOD_NAME: &'static str = "Player.SetAvatarFrame#1";
    type Response = CPlayer_SetAvatarFrame_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_SetCommunityPreferences_Request {
    const METHOD_NAME: &'static str = "Player.SetCommunityPreferences#1";
    type Response = CPlayer_SetCommunityPreferences_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_SetEquippedProfileItemFlags_Request {
    const METHOD_NAME: &'static str = "Player.SetEquippedProfileItemFlags#1";
    type Response = CPlayer_SetEquippedProfileItemFlags_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_SetFavoriteBadge_Request {
    const METHOD_NAME: &'static str = "Player.SetFavoriteBadge#1";
    type Response = CPlayer_SetFavoriteBadge_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_SetMiniProfileBackground_Request {
    const METHOD_NAME: &'static str = "Player.SetMiniProfileBackground#1";
    type Response = CPlayer_SetMiniProfileBackground_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_SetPerFriendPreferences_Request {
    const METHOD_NAME: &'static str = "Player.SetPerFriendPreferences#1";
    type Response = CPlayer_SetPerFriendPreferences_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_SetProfileBackground_Request {
    const METHOD_NAME: &'static str = "Player.SetProfileBackground#1";
    type Response = CPlayer_SetProfileBackground_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_SetProfilePreferences_Request {
    const METHOD_NAME: &'static str = "Player.SetProfilePreferences#1";
    type Response = CPlayer_SetProfilePreferences_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_SetProfileTheme_Request {
    const METHOD_NAME: &'static str = "Player.SetProfileTheme#1";
    type Response = CPlayer_SetProfileTheme_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CPlayer_SetSteamDeckKeyboardSkin_Request {
    const METHOD_NAME: &'static str = "Player.SetSteamDeckKeyboardSkin#1";
    type Response = CPlayer_SetSteamDeckKeyboardSkin_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_TextFilterWordsChanged_Notification {
    const METHOD_NAME: &'static str = "PlayerClient.NotifyTextFilterWordsChanged#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod
for CPlayer_UpdateSteamAnnouncementLastRead_Request {
    const METHOD_NAME: &'static str = "Player.UpdateSteamAnnouncementLastRead#1";
    type Response = CPlayer_UpdateSteamAnnouncementLastRead_Response;
}
