// 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_qms.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:GameSearchParam)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GameSearchParam {
    // message fields
    // @@protoc_insertion_point(field:GameSearchParam.key_name)
    pub key_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:GameSearchParam.value)
    pub value: ::std::vec::Vec<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:GameSearchParam.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string key_name = 1;

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

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

    pub fn has_key_name(&self) -> bool {
        self.key_name.is_some()
    }

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

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

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

    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.key_name = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.value.push(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.key_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        for value in &self.value {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_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.key_name.as_ref() {
            os.write_string(1, v)?;
        }
        for v in &self.value {
            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() -> GameSearchParam {
        GameSearchParam::new()
    }

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

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

// @@protoc_insertion_point(message:CQueuedMatchmaking_SearchForGame_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CQueuedMatchmaking_SearchForGame_Request {
    // message fields
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Request.action)
    pub action: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<EGameSearchAction>>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Request.params)
    pub params: ::std::vec::Vec<GameSearchParam>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Request.player_min)
    pub player_min: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Request.player_max)
    pub player_max: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Request.steamidlobby)
    pub steamidlobby: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Request.searchid)
    pub searchid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CQueuedMatchmaking_SearchForGame_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl CQueuedMatchmaking_SearchForGame_Request {
    pub fn new() -> CQueuedMatchmaking_SearchForGame_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 .EGameSearchAction action = 2;

    pub fn action(&self) -> EGameSearchAction {
        match self.action {
            Some(e) => e.enum_value_or(EGameSearchAction::k_EGameSearchAction_None),
            None => EGameSearchAction::k_EGameSearchAction_None,
        }
    }

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

    pub fn has_action(&self) -> bool {
        self.action.is_some()
    }

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

    // optional uint32 player_min = 4;

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

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

    pub fn has_player_min(&self) -> bool {
        self.player_min.is_some()
    }

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

    // optional uint32 player_max = 5;

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

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

    pub fn has_player_max(&self) -> bool {
        self.player_max.is_some()
    }

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

    // optional fixed64 steamidlobby = 6;

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

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

    pub fn has_steamidlobby(&self) -> bool {
        self.steamidlobby.is_some()
    }

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

    // optional uint64 searchid = 7;

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

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

    pub fn has_searchid(&self) -> bool {
        self.searchid.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.action = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                26 => {
                    self.params.push(is.read_message()?);
                },
                32 => {
                    self.player_min = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.player_max = ::std::option::Option::Some(is.read_uint32()?);
                },
                49 => {
                    self.steamidlobby = ::std::option::Option::Some(is.read_fixed64()?);
                },
                56 => {
                    self.searchid = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.action {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v.value());
        }
        for value in &self.params {
            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.player_min {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.player_max {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.steamidlobby {
            my_size += 1 + 8;
        }
        if let Some(v) = self.searchid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.action {
            os.write_enum(2, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        for v in &self.params {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        if let Some(v) = self.player_min {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.player_max {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.steamidlobby {
            os.write_fixed64(6, v)?;
        }
        if let Some(v) = self.searchid {
            os.write_uint64(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() -> CQueuedMatchmaking_SearchForGame_Request {
        CQueuedMatchmaking_SearchForGame_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.action = ::std::option::Option::None;
        self.params.clear();
        self.player_min = ::std::option::Option::None;
        self.player_max = ::std::option::Option::None;
        self.steamidlobby = ::std::option::Option::None;
        self.searchid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CQueuedMatchmaking_SearchForGame_Request {
        static instance: CQueuedMatchmaking_SearchForGame_Request = CQueuedMatchmaking_SearchForGame_Request {
            appid: ::std::option::Option::None,
            action: ::std::option::Option::None,
            params: ::std::vec::Vec::new(),
            player_min: ::std::option::Option::None,
            player_max: ::std::option::Option::None,
            steamidlobby: ::std::option::Option::None,
            searchid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CQueuedMatchmaking_SearchForGame_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CQueuedMatchmaking_SearchForGame_Response {
    // message fields
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Response.gamesearchresult)
    pub gamesearchresult: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<EGameSearchResult>>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Response.searchid)
    pub searchid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Response.seconds_time_estimate)
    pub seconds_time_estimate: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Response.poll_frequency)
    pub poll_frequency: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Response.count_searching)
    pub count_searching: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Response.players_in_match)
    pub players_in_match: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Response.players_accepted)
    pub players_accepted: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Response.connect_string)
    pub connect_string: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Response.steamidhost)
    pub steamidhost: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Response.rtime_match_made)
    pub rtime_match_made: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Response.rtime_now)
    pub rtime_now: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmaking_SearchForGame_Response.steamid_canceled_search)
    pub steamid_canceled_search: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CQueuedMatchmaking_SearchForGame_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional .EGameSearchResult gamesearchresult = 1;

    pub fn gamesearchresult(&self) -> EGameSearchResult {
        match self.gamesearchresult {
            Some(e) => e.enum_value_or(EGameSearchResult::k_EGameSearchResult_Invalid),
            None => EGameSearchResult::k_EGameSearchResult_Invalid,
        }
    }

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

    pub fn has_gamesearchresult(&self) -> bool {
        self.gamesearchresult.is_some()
    }

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

    // optional uint64 searchid = 2;

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

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

    pub fn has_searchid(&self) -> bool {
        self.searchid.is_some()
    }

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

    // optional uint32 seconds_time_estimate = 3;

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

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

    pub fn has_seconds_time_estimate(&self) -> bool {
        self.seconds_time_estimate.is_some()
    }

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

    // optional uint32 poll_frequency = 4;

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

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

    pub fn has_poll_frequency(&self) -> bool {
        self.poll_frequency.is_some()
    }

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

    // optional uint32 count_searching = 5;

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

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

    pub fn has_count_searching(&self) -> bool {
        self.count_searching.is_some()
    }

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

    // optional uint32 players_in_match = 6;

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

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

    pub fn has_players_in_match(&self) -> bool {
        self.players_in_match.is_some()
    }

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

    // optional uint32 players_accepted = 7;

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

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

    pub fn has_players_accepted(&self) -> bool {
        self.players_accepted.is_some()
    }

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

    // optional string connect_string = 9;

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

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

    pub fn has_connect_string(&self) -> bool {
        self.connect_string.is_some()
    }

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

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

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

    // optional fixed64 steamidhost = 10;

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

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

    pub fn has_steamidhost(&self) -> bool {
        self.steamidhost.is_some()
    }

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

    // optional uint32 rtime_match_made = 11;

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

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

    pub fn has_rtime_match_made(&self) -> bool {
        self.rtime_match_made.is_some()
    }

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

    // optional uint32 rtime_now = 12;

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

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

    pub fn has_rtime_now(&self) -> bool {
        self.rtime_now.is_some()
    }

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

    // optional fixed64 steamid_canceled_search = 13;

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

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

    pub fn has_steamid_canceled_search(&self) -> bool {
        self.steamid_canceled_search.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CQueuedMatchmaking_SearchForGame_Response {
    const NAME: &'static str = "CQueuedMatchmaking_SearchForGame_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.gamesearchresult = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                16 => {
                    self.searchid = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.seconds_time_estimate = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.poll_frequency = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.count_searching = ::std::option::Option::Some(is.read_uint32()?);
                },
                48 => {
                    self.players_in_match = ::std::option::Option::Some(is.read_uint32()?);
                },
                56 => {
                    self.players_accepted = ::std::option::Option::Some(is.read_uint32()?);
                },
                74 => {
                    self.connect_string = ::std::option::Option::Some(is.read_string()?);
                },
                81 => {
                    self.steamidhost = ::std::option::Option::Some(is.read_fixed64()?);
                },
                88 => {
                    self.rtime_match_made = ::std::option::Option::Some(is.read_uint32()?);
                },
                96 => {
                    self.rtime_now = ::std::option::Option::Some(is.read_uint32()?);
                },
                105 => {
                    self.steamid_canceled_search = ::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.gamesearchresult {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v.value());
        }
        if let Some(v) = self.searchid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.seconds_time_estimate {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.poll_frequency {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.count_searching {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.players_in_match {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.players_accepted {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.connect_string.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &v);
        }
        if let Some(v) = self.steamidhost {
            my_size += 1 + 8;
        }
        if let Some(v) = self.rtime_match_made {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(11, v);
        }
        if let Some(v) = self.rtime_now {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(12, v);
        }
        if let Some(v) = self.steamid_canceled_search {
            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.gamesearchresult {
            os.write_enum(1, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.searchid {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.seconds_time_estimate {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.poll_frequency {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.count_searching {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.players_in_match {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.players_accepted {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.connect_string.as_ref() {
            os.write_string(9, v)?;
        }
        if let Some(v) = self.steamidhost {
            os.write_fixed64(10, v)?;
        }
        if let Some(v) = self.rtime_match_made {
            os.write_uint32(11, v)?;
        }
        if let Some(v) = self.rtime_now {
            os.write_uint32(12, v)?;
        }
        if let Some(v) = self.steamid_canceled_search {
            os.write_fixed64(13, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.gamesearchresult = ::std::option::Option::None;
        self.searchid = ::std::option::Option::None;
        self.seconds_time_estimate = ::std::option::Option::None;
        self.poll_frequency = ::std::option::Option::None;
        self.count_searching = ::std::option::Option::None;
        self.players_in_match = ::std::option::Option::None;
        self.players_accepted = ::std::option::Option::None;
        self.connect_string = ::std::option::Option::None;
        self.steamidhost = ::std::option::Option::None;
        self.rtime_match_made = ::std::option::Option::None;
        self.rtime_now = ::std::option::Option::None;
        self.steamid_canceled_search = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CQueuedMatchmaking_SearchForGame_Response {
        static instance: CQueuedMatchmaking_SearchForGame_Response = CQueuedMatchmaking_SearchForGame_Response {
            gamesearchresult: ::std::option::Option::None,
            searchid: ::std::option::Option::None,
            seconds_time_estimate: ::std::option::Option::None,
            poll_frequency: ::std::option::Option::None,
            count_searching: ::std::option::Option::None,
            players_in_match: ::std::option::Option::None,
            players_accepted: ::std::option::Option::None,
            connect_string: ::std::option::Option::None,
            steamidhost: ::std::option::Option::None,
            rtime_match_made: ::std::option::Option::None,
            rtime_now: ::std::option::Option::None,
            steamid_canceled_search: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CQueuedMatchmakingGameHost_SearchForPlayers_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CQueuedMatchmakingGameHost_SearchForPlayers_Request {
    // message fields
    // @@protoc_insertion_point(field:CQueuedMatchmakingGameHost_SearchForPlayers_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmakingGameHost_SearchForPlayers_Request.action)
    pub action: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<EGameSearchAction>>,
    // @@protoc_insertion_point(field:CQueuedMatchmakingGameHost_SearchForPlayers_Request.params)
    pub params: ::std::vec::Vec<GameSearchParam>,
    // @@protoc_insertion_point(field:CQueuedMatchmakingGameHost_SearchForPlayers_Request.player_min)
    pub player_min: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmakingGameHost_SearchForPlayers_Request.player_max)
    pub player_max: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmakingGameHost_SearchForPlayers_Request.player_max_team_size)
    pub player_max_team_size: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmakingGameHost_SearchForPlayers_Request.connection_string)
    pub connection_string: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CQueuedMatchmakingGameHost_SearchForPlayers_Request.searchid)
    pub searchid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CQueuedMatchmakingGameHost_SearchForPlayers_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl CQueuedMatchmakingGameHost_SearchForPlayers_Request {
    pub fn new() -> CQueuedMatchmakingGameHost_SearchForPlayers_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 .EGameSearchAction action = 2;

    pub fn action(&self) -> EGameSearchAction {
        match self.action {
            Some(e) => e.enum_value_or(EGameSearchAction::k_EGameSearchAction_None),
            None => EGameSearchAction::k_EGameSearchAction_None,
        }
    }

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

    pub fn has_action(&self) -> bool {
        self.action.is_some()
    }

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

    // optional uint32 player_min = 4;

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

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

    pub fn has_player_min(&self) -> bool {
        self.player_min.is_some()
    }

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

    // optional uint32 player_max = 5;

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

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

    pub fn has_player_max(&self) -> bool {
        self.player_max.is_some()
    }

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

    // optional uint32 player_max_team_size = 6;

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

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

    pub fn has_player_max_team_size(&self) -> bool {
        self.player_max_team_size.is_some()
    }

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

    // optional string connection_string = 7;

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

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

    pub fn has_connection_string(&self) -> bool {
        self.connection_string.is_some()
    }

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

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

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

    // optional uint64 searchid = 8;

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

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

    pub fn has_searchid(&self) -> bool {
        self.searchid.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.action = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                26 => {
                    self.params.push(is.read_message()?);
                },
                32 => {
                    self.player_min = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.player_max = ::std::option::Option::Some(is.read_uint32()?);
                },
                48 => {
                    self.player_max_team_size = ::std::option::Option::Some(is.read_uint32()?);
                },
                58 => {
                    self.connection_string = ::std::option::Option::Some(is.read_string()?);
                },
                64 => {
                    self.searchid = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.action {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v.value());
        }
        for value in &self.params {
            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.player_min {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.player_max {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.player_max_team_size {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.connection_string.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
        }
        if let Some(v) = self.searchid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.action {
            os.write_enum(2, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        for v in &self.params {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        if let Some(v) = self.player_min {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.player_max {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.player_max_team_size {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.connection_string.as_ref() {
            os.write_string(7, v)?;
        }
        if let Some(v) = self.searchid {
            os.write_uint64(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() -> CQueuedMatchmakingGameHost_SearchForPlayers_Request {
        CQueuedMatchmakingGameHost_SearchForPlayers_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.action = ::std::option::Option::None;
        self.params.clear();
        self.player_min = ::std::option::Option::None;
        self.player_max = ::std::option::Option::None;
        self.player_max_team_size = ::std::option::Option::None;
        self.connection_string = ::std::option::Option::None;
        self.searchid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CQueuedMatchmakingGameHost_SearchForPlayers_Request {
        static instance: CQueuedMatchmakingGameHost_SearchForPlayers_Request = CQueuedMatchmakingGameHost_SearchForPlayers_Request {
            appid: ::std::option::Option::None,
            action: ::std::option::Option::None,
            params: ::std::vec::Vec::new(),
            player_min: ::std::option::Option::None,
            player_max: ::std::option::Option::None,
            player_max_team_size: ::std::option::Option::None,
            connection_string: ::std::option::Option::None,
            searchid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

impl PlayerFound {
    pub fn new() -> PlayerFound {
        ::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 .EGameSearchAction action = 2;

    pub fn action(&self) -> EGameSearchAction {
        match self.action {
            Some(e) => e.enum_value_or(EGameSearchAction::k_EGameSearchAction_None),
            None => EGameSearchAction::k_EGameSearchAction_None,
        }
    }

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

    pub fn has_action(&self) -> bool {
        self.action.is_some()
    }

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

    // optional uint32 team_number = 4;

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

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

    pub fn has_team_number(&self) -> bool {
        self.team_number.is_some()
    }

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

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

    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.action = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                26 => {
                    self.params.push(is.read_message()?);
                },
                32 => {
                    self.team_number = ::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.action {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v.value());
        }
        for value in &self.params {
            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.team_number {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.action {
            os.write_enum(2, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        for v in &self.params {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        if let Some(v) = self.team_number {
            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() -> PlayerFound {
        PlayerFound::new()
    }

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

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

// @@protoc_insertion_point(message:CQueuedMatchmakingGameHost_SearchForPlayers_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CQueuedMatchmakingGameHost_SearchForPlayers_Response {
    // message fields
    // @@protoc_insertion_point(field:CQueuedMatchmakingGameHost_SearchForPlayers_Response.gamesearchresult)
    pub gamesearchresult: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<EGameSearchResult>>,
    // @@protoc_insertion_point(field:CQueuedMatchmakingGameHost_SearchForPlayers_Response.searchid)
    pub searchid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CQueuedMatchmakingGameHost_SearchForPlayers_Response.poll_frequency)
    pub poll_frequency: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmakingGameHost_SearchForPlayers_Response.matchid)
    pub matchid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CQueuedMatchmakingGameHost_SearchForPlayers_Response.players)
    pub players: ::std::vec::Vec<PlayerFound>,
    // @@protoc_insertion_point(field:CQueuedMatchmakingGameHost_SearchForPlayers_Response.rtime_match_made)
    pub rtime_match_made: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CQueuedMatchmakingGameHost_SearchForPlayers_Response.rtime_now)
    pub rtime_now: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CQueuedMatchmakingGameHost_SearchForPlayers_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional .EGameSearchResult gamesearchresult = 1;

    pub fn gamesearchresult(&self) -> EGameSearchResult {
        match self.gamesearchresult {
            Some(e) => e.enum_value_or(EGameSearchResult::k_EGameSearchResult_Invalid),
            None => EGameSearchResult::k_EGameSearchResult_Invalid,
        }
    }

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

    pub fn has_gamesearchresult(&self) -> bool {
        self.gamesearchresult.is_some()
    }

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

    // optional uint64 searchid = 2;

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

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

    pub fn has_searchid(&self) -> bool {
        self.searchid.is_some()
    }

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

    // optional uint32 poll_frequency = 3;

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

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

    pub fn has_poll_frequency(&self) -> bool {
        self.poll_frequency.is_some()
    }

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

    // optional uint64 matchid = 4;

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

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

    pub fn has_matchid(&self) -> bool {
        self.matchid.is_some()
    }

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

    // optional uint32 rtime_match_made = 6;

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

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

    pub fn has_rtime_match_made(&self) -> bool {
        self.rtime_match_made.is_some()
    }

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

    // optional uint32 rtime_now = 7;

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

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

    pub fn has_rtime_now(&self) -> bool {
        self.rtime_now.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CQueuedMatchmakingGameHost_SearchForPlayers_Response {
    const NAME: &'static str = "CQueuedMatchmakingGameHost_SearchForPlayers_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.gamesearchresult = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                16 => {
                    self.searchid = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.poll_frequency = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.matchid = ::std::option::Option::Some(is.read_uint64()?);
                },
                42 => {
                    self.players.push(is.read_message()?);
                },
                48 => {
                    self.rtime_match_made = ::std::option::Option::Some(is.read_uint32()?);
                },
                56 => {
                    self.rtime_now = ::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.gamesearchresult {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v.value());
        }
        if let Some(v) = self.searchid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.poll_frequency {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.matchid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(4, v);
        }
        for value in &self.players {
            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.rtime_match_made {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.rtime_now {
            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.gamesearchresult {
            os.write_enum(1, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.searchid {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.poll_frequency {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.matchid {
            os.write_uint64(4, v)?;
        }
        for v in &self.players {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        };
        if let Some(v) = self.rtime_match_made {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.rtime_now {
            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() -> CQueuedMatchmakingGameHost_SearchForPlayers_Response {
        CQueuedMatchmakingGameHost_SearchForPlayers_Response::new()
    }

    fn clear(&mut self) {
        self.gamesearchresult = ::std::option::Option::None;
        self.searchid = ::std::option::Option::None;
        self.poll_frequency = ::std::option::Option::None;
        self.matchid = ::std::option::Option::None;
        self.players.clear();
        self.rtime_match_made = ::std::option::Option::None;
        self.rtime_now = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CQueuedMatchmakingGameHost_SearchForPlayers_Response {
        static instance: CQueuedMatchmakingGameHost_SearchForPlayers_Response = CQueuedMatchmakingGameHost_SearchForPlayers_Response {
            gamesearchresult: ::std::option::Option::None,
            searchid: ::std::option::Option::None,
            poll_frequency: ::std::option::Option::None,
            matchid: ::std::option::Option::None,
            players: ::std::vec::Vec::new(),
            rtime_match_made: ::std::option::Option::None,
            rtime_now: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

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

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

    pub fn has_value(&self) -> bool {
        self.value.is_some()
    }

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

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

    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.value = ::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.value {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

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

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

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

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

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

impl CQueuedMatchmakingGameHost_SubmitPlayerResult_Request {
    pub fn new() -> CQueuedMatchmakingGameHost_SubmitPlayerResult_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 uint64 matchid = 2;

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

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

    pub fn has_matchid(&self) -> bool {
        self.matchid.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.matchid = ::std::option::Option::Some(is.read_uint64()?);
                },
                26 => {
                    self.player_results.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.matchid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        for value in &self.player_results {
            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.matchid {
            os.write_uint64(2, v)?;
        }
        for v in &self.player_results {
            ::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() -> CQueuedMatchmakingGameHost_SubmitPlayerResult_Request {
        CQueuedMatchmakingGameHost_SubmitPlayerResult_Request::new()
    }

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

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

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

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

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

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

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

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

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

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

impl CQueuedMatchmakingGameHost_EndGame_Request {
    pub fn new() -> CQueuedMatchmakingGameHost_EndGame_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 uint64 matchid = 2;

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

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

    pub fn has_matchid(&self) -> bool {
        self.matchid.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.matchid = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.matchid {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.matchid {
            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() -> CQueuedMatchmakingGameHost_EndGame_Request {
        CQueuedMatchmakingGameHost_EndGame_Request::new()
    }

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

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

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

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

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

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

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

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

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:EGameSearchAction)
pub enum EGameSearchAction {
    // @@protoc_insertion_point(enum_value:EGameSearchAction.k_EGameSearchAction_None)
    k_EGameSearchAction_None = 0,
    // @@protoc_insertion_point(enum_value:EGameSearchAction.k_EGameSearchAction_Accept)
    k_EGameSearchAction_Accept = 1,
    // @@protoc_insertion_point(enum_value:EGameSearchAction.k_EGameSearchAction_Decline)
    k_EGameSearchAction_Decline = 2,
    // @@protoc_insertion_point(enum_value:EGameSearchAction.k_EGameSearchAction_Cancel)
    k_EGameSearchAction_Cancel = 3,
}

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

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

    fn from_i32(value: i32) -> ::std::option::Option<EGameSearchAction> {
        match value {
            0 => ::std::option::Option::Some(EGameSearchAction::k_EGameSearchAction_None),
            1 => ::std::option::Option::Some(EGameSearchAction::k_EGameSearchAction_Accept),
            2 => ::std::option::Option::Some(EGameSearchAction::k_EGameSearchAction_Decline),
            3 => ::std::option::Option::Some(EGameSearchAction::k_EGameSearchAction_Cancel),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<EGameSearchAction> {
        match str {
            "k_EGameSearchAction_None" => ::std::option::Option::Some(EGameSearchAction::k_EGameSearchAction_None),
            "k_EGameSearchAction_Accept" => ::std::option::Option::Some(EGameSearchAction::k_EGameSearchAction_Accept),
            "k_EGameSearchAction_Decline" => ::std::option::Option::Some(EGameSearchAction::k_EGameSearchAction_Decline),
            "k_EGameSearchAction_Cancel" => ::std::option::Option::Some(EGameSearchAction::k_EGameSearchAction_Cancel),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [EGameSearchAction] = &[
        EGameSearchAction::k_EGameSearchAction_None,
        EGameSearchAction::k_EGameSearchAction_Accept,
        EGameSearchAction::k_EGameSearchAction_Decline,
        EGameSearchAction::k_EGameSearchAction_Cancel,
    ];
}

impl ::std::default::Default for EGameSearchAction {
    fn default() -> Self {
        EGameSearchAction::k_EGameSearchAction_None
    }
}


#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:EGameSearchResult)
pub enum EGameSearchResult {
    // @@protoc_insertion_point(enum_value:EGameSearchResult.k_EGameSearchResult_Invalid)
    k_EGameSearchResult_Invalid = 0,
    // @@protoc_insertion_point(enum_value:EGameSearchResult.k_EGameSearchResult_SearchInProgress)
    k_EGameSearchResult_SearchInProgress = 1,
    // @@protoc_insertion_point(enum_value:EGameSearchResult.k_EGameSearchResult_SearchFailedNoHosts)
    k_EGameSearchResult_SearchFailedNoHosts = 2,
    // @@protoc_insertion_point(enum_value:EGameSearchResult.k_EGameSearchResult_SearchGameFound)
    k_EGameSearchResult_SearchGameFound = 3,
    // @@protoc_insertion_point(enum_value:EGameSearchResult.k_EGameSearchResult_SearchCompleteAccepted)
    k_EGameSearchResult_SearchCompleteAccepted = 4,
    // @@protoc_insertion_point(enum_value:EGameSearchResult.k_EGameSearchResult_SearchCompleteDeclined)
    k_EGameSearchResult_SearchCompleteDeclined = 5,
    // @@protoc_insertion_point(enum_value:EGameSearchResult.k_EGameSearchResult_SearchCanceled)
    k_EGameSearchResult_SearchCanceled = 6,
}

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

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

    fn from_i32(value: i32) -> ::std::option::Option<EGameSearchResult> {
        match value {
            0 => ::std::option::Option::Some(EGameSearchResult::k_EGameSearchResult_Invalid),
            1 => ::std::option::Option::Some(EGameSearchResult::k_EGameSearchResult_SearchInProgress),
            2 => ::std::option::Option::Some(EGameSearchResult::k_EGameSearchResult_SearchFailedNoHosts),
            3 => ::std::option::Option::Some(EGameSearchResult::k_EGameSearchResult_SearchGameFound),
            4 => ::std::option::Option::Some(EGameSearchResult::k_EGameSearchResult_SearchCompleteAccepted),
            5 => ::std::option::Option::Some(EGameSearchResult::k_EGameSearchResult_SearchCompleteDeclined),
            6 => ::std::option::Option::Some(EGameSearchResult::k_EGameSearchResult_SearchCanceled),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<EGameSearchResult> {
        match str {
            "k_EGameSearchResult_Invalid" => ::std::option::Option::Some(EGameSearchResult::k_EGameSearchResult_Invalid),
            "k_EGameSearchResult_SearchInProgress" => ::std::option::Option::Some(EGameSearchResult::k_EGameSearchResult_SearchInProgress),
            "k_EGameSearchResult_SearchFailedNoHosts" => ::std::option::Option::Some(EGameSearchResult::k_EGameSearchResult_SearchFailedNoHosts),
            "k_EGameSearchResult_SearchGameFound" => ::std::option::Option::Some(EGameSearchResult::k_EGameSearchResult_SearchGameFound),
            "k_EGameSearchResult_SearchCompleteAccepted" => ::std::option::Option::Some(EGameSearchResult::k_EGameSearchResult_SearchCompleteAccepted),
            "k_EGameSearchResult_SearchCompleteDeclined" => ::std::option::Option::Some(EGameSearchResult::k_EGameSearchResult_SearchCompleteDeclined),
            "k_EGameSearchResult_SearchCanceled" => ::std::option::Option::Some(EGameSearchResult::k_EGameSearchResult_SearchCanceled),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [EGameSearchResult] = &[
        EGameSearchResult::k_EGameSearchResult_Invalid,
        EGameSearchResult::k_EGameSearchResult_SearchInProgress,
        EGameSearchResult::k_EGameSearchResult_SearchFailedNoHosts,
        EGameSearchResult::k_EGameSearchResult_SearchGameFound,
        EGameSearchResult::k_EGameSearchResult_SearchCompleteAccepted,
        EGameSearchResult::k_EGameSearchResult_SearchCompleteDeclined,
        EGameSearchResult::k_EGameSearchResult_SearchCanceled,
    ];
}

impl ::std::default::Default for EGameSearchResult {
    fn default() -> Self {
        EGameSearchResult::k_EGameSearchResult_Invalid
    }
}



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

#[allow(unused_imports)]
use crate::steammessages_base::*;
#[allow(unused_imports)]
use crate::steammessages_unified_base_steamclient::*;
impl ::steam_vent_proto_common::RpcMessage for GameSearchParam {
    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 CQueuedMatchmaking_SearchForGame_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 CQueuedMatchmaking_SearchForGame_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 CQueuedMatchmakingGameHost_SearchForPlayers_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 PlayerFound {
    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 CQueuedMatchmakingGameHost_SearchForPlayers_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 PlayerResult {
    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 CQueuedMatchmakingGameHost_SubmitPlayerResult_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 CQueuedMatchmakingGameHost_SubmitPlayerResult_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 CQueuedMatchmakingGameHost_EndGame_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 CQueuedMatchmakingGameHost_EndGame_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
///
struct QueuedMatchmaking {}
impl ::steam_vent_proto_common::RpcService for QueuedMatchmaking {
    const SERVICE_NAME: &'static str = "QueuedMatchmaking";
}
///
struct QueuedMatchmakingGameHost {}
impl ::steam_vent_proto_common::RpcService for QueuedMatchmakingGameHost {
    const SERVICE_NAME: &'static str = "QueuedMatchmakingGameHost";
}
impl ::steam_vent_proto_common::RpcMethod
for CQueuedMatchmakingGameHost_EndGame_Request {
    const METHOD_NAME: &'static str = "QueuedMatchmakingGameHost.EndGame#1";
    type Response = CQueuedMatchmakingGameHost_EndGame_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CQueuedMatchmakingGameHost_SearchForPlayers_Request {
    const METHOD_NAME: &'static str = "QueuedMatchmakingGameHost.SearchForPlayers#1";
    type Response = CQueuedMatchmakingGameHost_SearchForPlayers_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CQueuedMatchmakingGameHost_SubmitPlayerResult_Request {
    const METHOD_NAME: &'static str = "QueuedMatchmakingGameHost.SubmitPlayerResult#1";
    type Response = CQueuedMatchmakingGameHost_SubmitPlayerResult_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CQueuedMatchmaking_SearchForGame_Request {
    const METHOD_NAME: &'static str = "QueuedMatchmaking.SearchForGame#1";
    type Response = CQueuedMatchmaking_SearchForGame_Response;
}
