steam_vent_proto_steam/generated/

steammessages_remoteclient.rs

// This file is generated by rust-protobuf 3.5.1. Do not edit
// .proto file is parsed by pure
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]

#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]

//! Generated file from `steammessages_remoteclient.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:CMsgRemoteClientStatus)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgRemoteClientStatus {
    // message fields
    // @@protoc_insertion_point(field:CMsgRemoteClientStatus.client_id)
    pub client_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStatus.instance_id)
    pub instance_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStatus.status)
    pub status: ::steam_vent_proto_common::protobuf::MessageField<super::steammessages_remoteclient_discovery::CMsgRemoteClientBroadcastStatus>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgRemoteClientStatus.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint64 client_id = 1;

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

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

    pub fn has_client_id(&self) -> bool {
        self.client_id.is_some()
    }

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

    // optional uint64 instance_id = 2;

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

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

    pub fn has_instance_id(&self) -> bool {
        self.instance_id.is_some()
    }

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

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

    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.client_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.instance_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                26 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.status)?;
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn default_instance() -> &'static CMsgRemoteClientStatus {
        static instance: CMsgRemoteClientStatus = CMsgRemoteClientStatus {
            client_id: ::std::option::Option::None,
            instance_id: ::std::option::Option::None,
            status: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

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

    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.status_updates.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

/// Nested message and enums of message `CMsgRemoteClientAppStatus`
pub mod cmsg_remote_client_app_status {
    // @@protoc_insertion_point(message:CMsgRemoteClientAppStatus.AppUpdateInfo)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct AppUpdateInfo {
        // message fields
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.AppUpdateInfo.time_update_start)
        pub time_update_start: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.AppUpdateInfo.bytes_to_download)
        pub bytes_to_download: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.AppUpdateInfo.bytes_downloaded)
        pub bytes_downloaded: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.AppUpdateInfo.bytes_to_process)
        pub bytes_to_process: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.AppUpdateInfo.bytes_processed)
        pub bytes_processed: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.AppUpdateInfo.estimated_seconds_remaining)
        pub estimated_seconds_remaining: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.AppUpdateInfo.update_result)
        pub update_result: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.AppUpdateInfo.update_state)
        pub update_state: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CMsgRemoteClientAppStatus.AppUpdateInfo.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional fixed32 time_update_start = 1;

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

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

        pub fn has_time_update_start(&self) -> bool {
            self.time_update_start.is_some()
        }

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

        // optional uint64 bytes_to_download = 2;

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

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

        pub fn has_bytes_to_download(&self) -> bool {
            self.bytes_to_download.is_some()
        }

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

        // optional uint64 bytes_downloaded = 3;

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

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

        pub fn has_bytes_downloaded(&self) -> bool {
            self.bytes_downloaded.is_some()
        }

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

        // optional uint64 bytes_to_process = 4;

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

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

        pub fn has_bytes_to_process(&self) -> bool {
            self.bytes_to_process.is_some()
        }

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

        // optional uint64 bytes_processed = 5;

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

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

        pub fn has_bytes_processed(&self) -> bool {
            self.bytes_processed.is_some()
        }

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

        // optional int32 estimated_seconds_remaining = 6;

        pub fn estimated_seconds_remaining(&self) -> i32 {
            self.estimated_seconds_remaining.unwrap_or(-1i32)
        }

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

        pub fn has_estimated_seconds_remaining(&self) -> bool {
            self.estimated_seconds_remaining.is_some()
        }

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

        // optional int32 update_result = 7;

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

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

        pub fn has_update_result(&self) -> bool {
            self.update_result.is_some()
        }

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

        // optional uint32 update_state = 8;

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

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

        pub fn has_update_state(&self) -> bool {
            self.update_state.is_some()
        }

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

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

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

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    13 => {
                        self.time_update_start = ::std::option::Option::Some(is.read_fixed32()?);
                    },
                    16 => {
                        self.bytes_to_download = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    24 => {
                        self.bytes_downloaded = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    32 => {
                        self.bytes_to_process = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    40 => {
                        self.bytes_processed = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    48 => {
                        self.estimated_seconds_remaining = ::std::option::Option::Some(is.read_int32()?);
                    },
                    56 => {
                        self.update_result = ::std::option::Option::Some(is.read_int32()?);
                    },
                    64 => {
                        self.update_state = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if let Some(v) = self.time_update_start {
                my_size += 1 + 4;
            }
            if let Some(v) = self.bytes_to_download {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
            }
            if let Some(v) = self.bytes_downloaded {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
            }
            if let Some(v) = self.bytes_to_process {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(4, v);
            }
            if let Some(v) = self.bytes_processed {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(5, v);
            }
            if let Some(v) = self.estimated_seconds_remaining {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(6, v);
            }
            if let Some(v) = self.update_result {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(7, v);
            }
            if let Some(v) = self.update_state {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_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.time_update_start {
                os.write_fixed32(1, v)?;
            }
            if let Some(v) = self.bytes_to_download {
                os.write_uint64(2, v)?;
            }
            if let Some(v) = self.bytes_downloaded {
                os.write_uint64(3, v)?;
            }
            if let Some(v) = self.bytes_to_process {
                os.write_uint64(4, v)?;
            }
            if let Some(v) = self.bytes_processed {
                os.write_uint64(5, v)?;
            }
            if let Some(v) = self.estimated_seconds_remaining {
                os.write_int32(6, v)?;
            }
            if let Some(v) = self.update_result {
                os.write_int32(7, v)?;
            }
            if let Some(v) = self.update_state {
                os.write_uint32(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() -> AppUpdateInfo {
            AppUpdateInfo::new()
        }

        fn clear(&mut self) {
            self.time_update_start = ::std::option::Option::None;
            self.bytes_to_download = ::std::option::Option::None;
            self.bytes_downloaded = ::std::option::Option::None;
            self.bytes_to_process = ::std::option::Option::None;
            self.bytes_processed = ::std::option::Option::None;
            self.estimated_seconds_remaining = ::std::option::Option::None;
            self.update_result = ::std::option::Option::None;
            self.update_state = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static AppUpdateInfo {
            static instance: AppUpdateInfo = AppUpdateInfo {
                time_update_start: ::std::option::Option::None,
                bytes_to_download: ::std::option::Option::None,
                bytes_downloaded: ::std::option::Option::None,
                bytes_to_process: ::std::option::Option::None,
                bytes_processed: ::std::option::Option::None,
                estimated_seconds_remaining: ::std::option::Option::None,
                update_result: ::std::option::Option::None,
                update_state: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:CMsgRemoteClientAppStatus.ShortcutInfo)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct ShortcutInfo {
        // message fields
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.ShortcutInfo.name)
        pub name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.ShortcutInfo.icon)
        pub icon: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.ShortcutInfo.categories)
        pub categories: ::std::vec::Vec<::std::string::String>,
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.ShortcutInfo.exepath)
        pub exepath: ::std::option::Option<::std::string::String>,
        // special fields
        // @@protoc_insertion_point(special_field:CMsgRemoteClientAppStatus.ShortcutInfo.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional string name = 1;

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

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

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

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

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

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

        // optional string icon = 2;

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

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

        pub fn has_icon(&self) -> bool {
            self.icon.is_some()
        }

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

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

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

        // optional string exepath = 4;

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

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

        pub fn has_exepath(&self) -> bool {
            self.exepath.is_some()
        }

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

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

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

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

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.name = ::std::option::Option::Some(is.read_string()?);
                    },
                    18 => {
                        self.icon = ::std::option::Option::Some(is.read_string()?);
                    },
                    26 => {
                        self.categories.push(is.read_string()?);
                    },
                    34 => {
                        self.exepath = ::std::option::Option::Some(is.read_string()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if let Some(v) = self.name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
            }
            if let Some(v) = self.icon.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
            }
            for value in &self.categories {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &value);
            };
            if let Some(v) = self.exepath.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.name.as_ref() {
                os.write_string(1, v)?;
            }
            if let Some(v) = self.icon.as_ref() {
                os.write_string(2, v)?;
            }
            for v in &self.categories {
                os.write_string(3, &v)?;
            };
            if let Some(v) = self.exepath.as_ref() {
                os.write_string(4, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

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

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

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

        fn clear(&mut self) {
            self.name = ::std::option::Option::None;
            self.icon = ::std::option::Option::None;
            self.categories.clear();
            self.exepath = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static ShortcutInfo {
            static instance: ShortcutInfo = ShortcutInfo {
                name: ::std::option::Option::None,
                icon: ::std::option::Option::None,
                categories: ::std::vec::Vec::new(),
                exepath: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:CMsgRemoteClientAppStatus.AppStatus)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct AppStatus {
        // message fields
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.AppStatus.app_id)
        pub app_id: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.AppStatus.app_state)
        pub app_state: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.AppStatus.update_info)
        pub update_info: ::steam_vent_proto_common::protobuf::MessageField<AppUpdateInfo>,
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.AppStatus.shortcut_info)
        pub shortcut_info: ::steam_vent_proto_common::protobuf::MessageField<ShortcutInfo>,
        // @@protoc_insertion_point(field:CMsgRemoteClientAppStatus.AppStatus.vr_not_required)
        pub vr_not_required: ::std::option::Option<bool>,
        // special fields
        // @@protoc_insertion_point(special_field:CMsgRemoteClientAppStatus.AppStatus.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional uint32 app_id = 1;

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

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

        pub fn has_app_id(&self) -> bool {
            self.app_id.is_some()
        }

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

        // optional uint32 app_state = 2;

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

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

        pub fn has_app_state(&self) -> bool {
            self.app_state.is_some()
        }

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

        // optional bool vr_not_required = 5;

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

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

        pub fn has_vr_not_required(&self) -> bool {
            self.vr_not_required.is_some()
        }

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

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

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

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.app_id = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    16 => {
                        self.app_state = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    26 => {
                        ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.update_info)?;
                    },
                    34 => {
                        ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.shortcut_info)?;
                    },
                    40 => {
                        self.vr_not_required = ::std::option::Option::Some(is.read_bool()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.app_id {
                os.write_uint32(1, v)?;
            }
            if let Some(v) = self.app_state {
                os.write_uint32(2, v)?;
            }
            if let Some(v) = self.update_info.as_ref() {
                ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
            }
            if let Some(v) = self.shortcut_info.as_ref() {
                ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
            }
            if let Some(v) = self.vr_not_required {
                os.write_bool(5, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

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

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

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

        fn clear(&mut self) {
            self.app_id = ::std::option::Option::None;
            self.app_state = ::std::option::Option::None;
            self.update_info.clear();
            self.shortcut_info.clear();
            self.vr_not_required = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static AppStatus {
            static instance: AppStatus = AppStatus {
                app_id: ::std::option::Option::None,
                app_state: ::std::option::Option::None,
                update_info: ::steam_vent_proto_common::protobuf::MessageField::none(),
                shortcut_info: ::steam_vent_proto_common::protobuf::MessageField::none(),
                vr_not_required: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CMsgRemoteClientStartStream)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgRemoteClientStartStream {
    // message fields
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStream.app_id)
    pub app_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStream.environment)
    pub environment: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStream.gamepad_count)
    pub gamepad_count: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStream.launch_option)
    pub launch_option: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStream.lock_parental_lock)
    pub lock_parental_lock: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStream.unlock_parental_lock)
    pub unlock_parental_lock: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStream.maximum_resolution_x)
    pub maximum_resolution_x: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStream.maximum_resolution_y)
    pub maximum_resolution_y: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStream.gamepads)
    pub gamepads: ::std::vec::Vec<cmsg_remote_client_start_stream::ReservedGamepad>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStream.audio_channel_count)
    pub audio_channel_count: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStream.supported_transport)
    pub supported_transport: ::std::vec::Vec<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::steammessages_remoteclient_discovery::EStreamTransport>>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgRemoteClientStartStream.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 app_id = 1;

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

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

    pub fn has_app_id(&self) -> bool {
        self.app_id.is_some()
    }

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

    // optional int32 environment = 2;

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

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

    pub fn has_environment(&self) -> bool {
        self.environment.is_some()
    }

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

    // optional int32 gamepad_count = 3;

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

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

    pub fn has_gamepad_count(&self) -> bool {
        self.gamepad_count.is_some()
    }

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

    // optional int32 launch_option = 4;

    pub fn launch_option(&self) -> i32 {
        self.launch_option.unwrap_or(-1i32)
    }

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

    pub fn has_launch_option(&self) -> bool {
        self.launch_option.is_some()
    }

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

    // optional bool lock_parental_lock = 5;

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

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

    pub fn has_lock_parental_lock(&self) -> bool {
        self.lock_parental_lock.is_some()
    }

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

    // optional string unlock_parental_lock = 6;

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

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

    pub fn has_unlock_parental_lock(&self) -> bool {
        self.unlock_parental_lock.is_some()
    }

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

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

    // optional int32 maximum_resolution_x = 7;

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

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

    pub fn has_maximum_resolution_x(&self) -> bool {
        self.maximum_resolution_x.is_some()
    }

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

    // optional int32 maximum_resolution_y = 8;

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

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

    pub fn has_maximum_resolution_y(&self) -> bool {
        self.maximum_resolution_y.is_some()
    }

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

    // optional int32 audio_channel_count = 10;

    pub fn audio_channel_count(&self) -> i32 {
        self.audio_channel_count.unwrap_or(2i32)
    }

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

    pub fn has_audio_channel_count(&self) -> bool {
        self.audio_channel_count.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.app_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.environment = ::std::option::Option::Some(is.read_int32()?);
                },
                24 => {
                    self.gamepad_count = ::std::option::Option::Some(is.read_int32()?);
                },
                32 => {
                    self.launch_option = ::std::option::Option::Some(is.read_int32()?);
                },
                40 => {
                    self.lock_parental_lock = ::std::option::Option::Some(is.read_bool()?);
                },
                50 => {
                    self.unlock_parental_lock = ::std::option::Option::Some(is.read_string()?);
                },
                56 => {
                    self.maximum_resolution_x = ::std::option::Option::Some(is.read_int32()?);
                },
                64 => {
                    self.maximum_resolution_y = ::std::option::Option::Some(is.read_int32()?);
                },
                74 => {
                    self.gamepads.push(is.read_message()?);
                },
                80 => {
                    self.audio_channel_count = ::std::option::Option::Some(is.read_int32()?);
                },
                88 => {
                    self.supported_transport.push(is.read_enum_or_unknown()?);
                },
                90 => {
                    ::steam_vent_proto_common::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.supported_transport)?
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.app_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.environment {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
        }
        if let Some(v) = self.gamepad_count {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v);
        }
        if let Some(v) = self.launch_option {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v);
        }
        if let Some(v) = self.lock_parental_lock {
            my_size += 1 + 1;
        }
        if let Some(v) = self.unlock_parental_lock.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.maximum_resolution_x {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(7, v);
        }
        if let Some(v) = self.maximum_resolution_y {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(8, v);
        }
        for value in &self.gamepads {
            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.audio_channel_count {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(10, v);
        }
        for value in &self.supported_transport {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(11, value.value());
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.app_id {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.environment {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.gamepad_count {
            os.write_int32(3, v)?;
        }
        if let Some(v) = self.launch_option {
            os.write_int32(4, v)?;
        }
        if let Some(v) = self.lock_parental_lock {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.unlock_parental_lock.as_ref() {
            os.write_string(6, v)?;
        }
        if let Some(v) = self.maximum_resolution_x {
            os.write_int32(7, v)?;
        }
        if let Some(v) = self.maximum_resolution_y {
            os.write_int32(8, v)?;
        }
        for v in &self.gamepads {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
        };
        if let Some(v) = self.audio_channel_count {
            os.write_int32(10, v)?;
        }
        for v in &self.supported_transport {
            os.write_enum(11, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(v))?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.app_id = ::std::option::Option::None;
        self.environment = ::std::option::Option::None;
        self.gamepad_count = ::std::option::Option::None;
        self.launch_option = ::std::option::Option::None;
        self.lock_parental_lock = ::std::option::Option::None;
        self.unlock_parental_lock = ::std::option::Option::None;
        self.maximum_resolution_x = ::std::option::Option::None;
        self.maximum_resolution_y = ::std::option::Option::None;
        self.gamepads.clear();
        self.audio_channel_count = ::std::option::Option::None;
        self.supported_transport.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgRemoteClientStartStream {
        static instance: CMsgRemoteClientStartStream = CMsgRemoteClientStartStream {
            app_id: ::std::option::Option::None,
            environment: ::std::option::Option::None,
            gamepad_count: ::std::option::Option::None,
            launch_option: ::std::option::Option::None,
            lock_parental_lock: ::std::option::Option::None,
            unlock_parental_lock: ::std::option::Option::None,
            maximum_resolution_x: ::std::option::Option::None,
            maximum_resolution_y: ::std::option::Option::None,
            gamepads: ::std::vec::Vec::new(),
            audio_channel_count: ::std::option::Option::None,
            supported_transport: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CMsgRemoteClientStartStream`
pub mod cmsg_remote_client_start_stream {
    // @@protoc_insertion_point(message:CMsgRemoteClientStartStream.ReservedGamepad)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct ReservedGamepad {
        // message fields
        // @@protoc_insertion_point(field:CMsgRemoteClientStartStream.ReservedGamepad.controller_type)
        pub controller_type: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CMsgRemoteClientStartStream.ReservedGamepad.controller_subtype)
        pub controller_subtype: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CMsgRemoteClientStartStream.ReservedGamepad.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional uint32 controller_type = 1;

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

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

        pub fn has_controller_type(&self) -> bool {
            self.controller_type.is_some()
        }

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

        // optional uint32 controller_subtype = 2;

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

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

        pub fn has_controller_subtype(&self) -> bool {
            self.controller_subtype.is_some()
        }

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

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

        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.controller_type = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    16 => {
                        self.controller_subtype = ::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.controller_type {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
            }
            if let Some(v) = self.controller_subtype {
                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.controller_type {
                os.write_uint32(1, v)?;
            }
            if let Some(v) = self.controller_subtype {
                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() -> ReservedGamepad {
            ReservedGamepad::new()
        }

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

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

// @@protoc_insertion_point(message:CMsgRemoteClientStartStreamResponse)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgRemoteClientStartStreamResponse {
    // message fields
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStreamResponse.e_launch_result)
    pub e_launch_result: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStreamResponse.stream_port)
    pub stream_port: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStreamResponse.launch_options)
    pub launch_options: ::std::vec::Vec<i32>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStreamResponse.auth_token)
    pub auth_token: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStreamResponse.transport)
    pub transport: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::steammessages_remoteclient_discovery::EStreamTransport>>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStreamResponse.relay_server)
    pub relay_server: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStreamResponse.launch_task)
    pub launch_task: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStreamResponse.launch_task_detail)
    pub launch_task_detail: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStreamResponse.launch_tasks_done)
    pub launch_tasks_done: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStreamResponse.launch_tasks_total)
    pub launch_tasks_total: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CMsgRemoteClientStartStreamResponse.vr_connection_params)
    pub vr_connection_params: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgRemoteClientStartStreamResponse.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional int32 e_launch_result = 1;

    pub fn e_launch_result(&self) -> i32 {
        self.e_launch_result.unwrap_or(2i32)
    }

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

    pub fn has_e_launch_result(&self) -> bool {
        self.e_launch_result.is_some()
    }

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

    // optional uint32 stream_port = 2;

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

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

    pub fn has_stream_port(&self) -> bool {
        self.stream_port.is_some()
    }

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

    // optional bytes auth_token = 4;

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

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

    pub fn has_auth_token(&self) -> bool {
        self.auth_token.is_some()
    }

    // Param is passed by value, moved
    pub fn set_auth_token(&mut self, v: ::std::vec::Vec<u8>) {
        self.auth_token = ::std::option::Option::Some(v);
    }

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

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

    // optional .EStreamTransport transport = 5;

    pub fn transport(&self) -> super::steammessages_remoteclient_discovery::EStreamTransport {
        match self.transport {
            Some(e) => e.enum_value_or(super::steammessages_remoteclient_discovery::EStreamTransport::k_EStreamTransportUDP),
            None => super::steammessages_remoteclient_discovery::EStreamTransport::k_EStreamTransportUDP,
        }
    }

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

    pub fn has_transport(&self) -> bool {
        self.transport.is_some()
    }

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

    // optional string relay_server = 6;

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

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

    pub fn has_relay_server(&self) -> bool {
        self.relay_server.is_some()
    }

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

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

    // optional string launch_task = 7;

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

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

    pub fn has_launch_task(&self) -> bool {
        self.launch_task.is_some()
    }

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

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

    // optional string launch_task_detail = 8;

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

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

    pub fn has_launch_task_detail(&self) -> bool {
        self.launch_task_detail.is_some()
    }

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

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

    // optional int32 launch_tasks_done = 9;

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

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

    pub fn has_launch_tasks_done(&self) -> bool {
        self.launch_tasks_done.is_some()
    }

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

    // optional int32 launch_tasks_total = 10;

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

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

    pub fn has_launch_tasks_total(&self) -> bool {
        self.launch_tasks_total.is_some()
    }

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

    // optional string vr_connection_params = 11;

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

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

    pub fn has_vr_connection_params(&self) -> bool {
        self.vr_connection_params.is_some()
    }

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

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

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

    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.e_launch_result = ::std::option::Option::Some(is.read_int32()?);
                },
                16 => {
                    self.stream_port = ::std::option::Option::Some(is.read_uint32()?);
                },
                26 => {
                    is.read_repeated_packed_int32_into(&mut self.launch_options)?;
                },
                24 => {
                    self.launch_options.push(is.read_int32()?);
                },
                34 => {
                    self.auth_token = ::std::option::Option::Some(is.read_bytes()?);
                },
                40 => {
                    self.transport = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                50 => {
                    self.relay_server = ::std::option::Option::Some(is.read_string()?);
                },
                58 => {
                    self.launch_task = ::std::option::Option::Some(is.read_string()?);
                },
                66 => {
                    self.launch_task_detail = ::std::option::Option::Some(is.read_string()?);
                },
                72 => {
                    self.launch_tasks_done = ::std::option::Option::Some(is.read_int32()?);
                },
                80 => {
                    self.launch_tasks_total = ::std::option::Option::Some(is.read_int32()?);
                },
                90 => {
                    self.vr_connection_params = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.e_launch_result {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
        }
        if let Some(v) = self.stream_port {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        for value in &self.launch_options {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, *value);
        };
        if let Some(v) = self.auth_token.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(4, &v);
        }
        if let Some(v) = self.transport {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v.value());
        }
        if let Some(v) = self.relay_server.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.launch_task.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
        }
        if let Some(v) = self.launch_task_detail.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(8, &v);
        }
        if let Some(v) = self.launch_tasks_done {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(9, v);
        }
        if let Some(v) = self.launch_tasks_total {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(10, v);
        }
        if let Some(v) = self.vr_connection_params.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(11, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.e_launch_result {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.stream_port {
            os.write_uint32(2, v)?;
        }
        for v in &self.launch_options {
            os.write_int32(3, *v)?;
        };
        if let Some(v) = self.auth_token.as_ref() {
            os.write_bytes(4, v)?;
        }
        if let Some(v) = self.transport {
            os.write_enum(5, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.relay_server.as_ref() {
            os.write_string(6, v)?;
        }
        if let Some(v) = self.launch_task.as_ref() {
            os.write_string(7, v)?;
        }
        if let Some(v) = self.launch_task_detail.as_ref() {
            os.write_string(8, v)?;
        }
        if let Some(v) = self.launch_tasks_done {
            os.write_int32(9, v)?;
        }
        if let Some(v) = self.launch_tasks_total {
            os.write_int32(10, v)?;
        }
        if let Some(v) = self.vr_connection_params.as_ref() {
            os.write_string(11, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.e_launch_result = ::std::option::Option::None;
        self.stream_port = ::std::option::Option::None;
        self.launch_options.clear();
        self.auth_token = ::std::option::Option::None;
        self.transport = ::std::option::Option::None;
        self.relay_server = ::std::option::Option::None;
        self.launch_task = ::std::option::Option::None;
        self.launch_task_detail = ::std::option::Option::None;
        self.launch_tasks_done = ::std::option::Option::None;
        self.launch_tasks_total = ::std::option::Option::None;
        self.vr_connection_params = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgRemoteClientStartStreamResponse {
        static instance: CMsgRemoteClientStartStreamResponse = CMsgRemoteClientStartStreamResponse {
            e_launch_result: ::std::option::Option::None,
            stream_port: ::std::option::Option::None,
            launch_options: ::std::vec::Vec::new(),
            auth_token: ::std::option::Option::None,
            transport: ::std::option::Option::None,
            relay_server: ::std::option::Option::None,
            launch_task: ::std::option::Option::None,
            launch_task_detail: ::std::option::Option::None,
            launch_tasks_done: ::std::option::Option::None,
            launch_tasks_total: ::std::option::Option::None,
            vr_connection_params: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

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

    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() -> CMsgRemoteClientPing {
        CMsgRemoteClientPing::new()
    }

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

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

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

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

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

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

    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() -> CMsgRemoteClientPingResponse {
        CMsgRemoteClientPingResponse::new()
    }

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

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    is.read_repeated_packed_uint32_into(&mut self.app_id)?;
                },
                8 => {
                    self.app_id.push(is.read_uint32()?);
                },
                18 => {
                    self.eula_id.push(is.read_string()?);
                },
                26 => {
                    is.read_repeated_packed_uint32_into(&mut self.eula_version)?;
                },
                24 => {
                    self.eula_version.push(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.app_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, *value);
        };
        for value in &self.eula_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &value);
        };
        for value in &self.eula_version {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, *value);
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.app_id {
            os.write_uint32(1, *v)?;
        };
        for v in &self.eula_id {
            os.write_string(2, &v)?;
        };
        for v in &self.eula_version {
            os.write_uint32(3, *v)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

    // optional uint32 app_id = 1;

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

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

    pub fn has_app_id(&self) -> bool {
        self.app_id.is_some()
    }

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

    // optional uint32 controller_index = 3;

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

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

    pub fn has_controller_index(&self) -> bool {
        self.controller_index.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional int32 eresult = 1;

    pub fn eresult(&self) -> i32 {
        self.eresult.unwrap_or(2i32)
    }

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

    pub fn has_eresult(&self) -> bool {
        self.eresult.is_some()
    }

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

    // optional bytes config_vdf = 2;

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

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

    pub fn has_config_vdf(&self) -> bool {
        self.config_vdf.is_some()
    }

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

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

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

    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.eresult = ::std::option::Option::Some(is.read_int32()?);
                },
                18 => {
                    self.config_vdf = ::std::option::Option::Some(is.read_bytes()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // required bool enabled = 1;

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

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

    pub fn has_enabled(&self) -> bool {
        self.enabled.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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


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

#[allow(unused_imports)]
use crate::steammessages_base::*;
#[allow(unused_imports)]
use crate::steammessages_remoteclient_discovery::*;
impl ::steam_vent_proto_common::RpcMessage for CMsgRemoteClientStatus {
    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 CMsgRemoteClientAppStatus {
    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::RpcMessageWithKind for CMsgRemoteClientAppStatus {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgRemoteClientAppStatus;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgRemoteClientStartStream {
    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::RpcMessageWithKind for CMsgRemoteClientStartStream {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgRemoteClientStartStream;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgRemoteClientStartStreamResponse {
    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::RpcMessageWithKind
for CMsgRemoteClientStartStreamResponse {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgRemoteClientStartStreamResponse;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgRemoteClientPing {
    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::RpcMessageWithKind for CMsgRemoteClientPing {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgRemoteClientPing;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgRemoteClientPingResponse {
    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::RpcMessageWithKind for CMsgRemoteClientPingResponse {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgRemoteClientPingResponse;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgRemoteClientAcceptEULA {
    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::RpcMessageWithKind for CMsgRemoteClientAcceptEULA {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgRemoteClientAcceptEULA;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgRemoteClientGetControllerConfig {
    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::RpcMessageWithKind
for CMsgRemoteClientGetControllerConfig {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgRemoteClientGetControllerConfig;
}
impl ::steam_vent_proto_common::RpcMessage
for CMsgRemoteClientGetControllerConfigResponse {
    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::RpcMessageWithKind
for CMsgRemoteClientGetControllerConfigResponse {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgRemoteClientGetControllerConfigResponse;
}
impl ::steam_vent_proto_common::RpcMessage for CMsgRemoteClientStreamingEnabled {
    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::RpcMessageWithKind for CMsgRemoteClientStreamingEnabled {
    type KindEnum = crate::enums_clientserver::EMsg;
    const KIND: Self::KindEnum = crate::enums_clientserver::EMsg::k_EMsgRemoteClientStreamingEnabled;
}