// This file is generated by rust-protobuf 3.4.0. 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(box_pointers)]
#![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_appoverview.proto`
// Generated for lite runtime

/// Generated files are compatible only with the same version
/// of protobuf runtime.
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_4_0;

// @@protoc_insertion_point(message:CAppOverview_AppAssociation)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CAppOverview_AppAssociation {
    // message fields
    // @@protoc_insertion_point(field:CAppOverview_AppAssociation.type)
    pub type_: ::std::option::Option<::protobuf::EnumOrUnknown<EAppAssociationType>>,
    // @@protoc_insertion_point(field:CAppOverview_AppAssociation.name)
    pub name: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CAppOverview_AppAssociation.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional .EAppAssociationType type = 1;

    pub fn type_(&self) -> EAppAssociationType {
        match self.type_ {
            Some(e) => e.enum_value_or(EAppAssociationType::k_EAppAssociationTypeInvalid),
            None => EAppAssociationType::k_EAppAssociationTypeInvalid,
        }
    }

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

    pub fn has_type(&self) -> bool {
        self.type_.is_some()
    }

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

    // optional string name = 2;

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

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

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.type_ = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                18 => {
                    self.name = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::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.type_ {
            my_size += ::protobuf::rt::int32_size(1, v.value());
        }
        if let Some(v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        my_size += ::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 ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.type_ {
            os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.name.as_ref() {
            os.write_string(2, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

// @@protoc_insertion_point(message:CAppOverview_PerClientData)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CAppOverview_PerClientData {
    // message fields
    // @@protoc_insertion_point(field:CAppOverview_PerClientData.clientid)
    pub clientid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CAppOverview_PerClientData.client_name)
    pub client_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CAppOverview_PerClientData.display_status)
    pub display_status: ::std::option::Option<::protobuf::EnumOrUnknown<EDisplayStatus>>,
    // @@protoc_insertion_point(field:CAppOverview_PerClientData.status_percentage)
    pub status_percentage: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview_PerClientData.active_beta)
    pub active_beta: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CAppOverview_PerClientData.installed)
    pub installed: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CAppOverview_PerClientData.bytes_downloaded)
    pub bytes_downloaded: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CAppOverview_PerClientData.bytes_total)
    pub bytes_total: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CAppOverview_PerClientData.streaming_to_local_client)
    pub streaming_to_local_client: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CAppOverview_PerClientData.is_available_on_current_platform)
    pub is_available_on_current_platform: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CAppOverview_PerClientData.is_invalid_os_type)
    pub is_invalid_os_type: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CAppOverview_PerClientData.playtime_left)
    pub playtime_left: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview_PerClientData.cloud_status)
    pub cloud_status: ::std::option::Option<::protobuf::EnumOrUnknown<EAppCloudStatus>>,
    // special fields
    // @@protoc_insertion_point(special_field:CAppOverview_PerClientData.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional uint64 clientid = 1;

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

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

    pub fn has_clientid(&self) -> bool {
        self.clientid.is_some()
    }

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

    // optional string client_name = 2;

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

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

    pub fn has_client_name(&self) -> bool {
        self.client_name.is_some()
    }

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

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

    // optional .EDisplayStatus display_status = 3;

    pub fn display_status(&self) -> EDisplayStatus {
        match self.display_status {
            Some(e) => e.enum_value_or(EDisplayStatus::k_EDisplayStatusInvalid),
            None => EDisplayStatus::k_EDisplayStatusInvalid,
        }
    }

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

    pub fn has_display_status(&self) -> bool {
        self.display_status.is_some()
    }

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

    // optional uint32 status_percentage = 4;

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

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

    pub fn has_status_percentage(&self) -> bool {
        self.status_percentage.is_some()
    }

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

    // optional string active_beta = 5;

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

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

    pub fn has_active_beta(&self) -> bool {
        self.active_beta.is_some()
    }

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

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

    // optional bool installed = 6;

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

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

    pub fn has_installed(&self) -> bool {
        self.installed.is_some()
    }

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

    // optional uint64 bytes_downloaded = 7;

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

    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_total = 8;

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

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

    pub fn has_bytes_total(&self) -> bool {
        self.bytes_total.is_some()
    }

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

    // optional bool streaming_to_local_client = 9;

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

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

    pub fn has_streaming_to_local_client(&self) -> bool {
        self.streaming_to_local_client.is_some()
    }

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

    // optional bool is_available_on_current_platform = 10;

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

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

    pub fn has_is_available_on_current_platform(&self) -> bool {
        self.is_available_on_current_platform.is_some()
    }

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

    // optional bool is_invalid_os_type = 11;

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

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

    pub fn has_is_invalid_os_type(&self) -> bool {
        self.is_invalid_os_type.is_some()
    }

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

    // optional uint32 playtime_left = 12;

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

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

    pub fn has_playtime_left(&self) -> bool {
        self.playtime_left.is_some()
    }

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

    // optional .EAppCloudStatus cloud_status = 13;

    pub fn cloud_status(&self) -> EAppCloudStatus {
        match self.cloud_status {
            Some(e) => e.enum_value_or(EAppCloudStatus::k_EAppCloudStatusInvalid),
            None => EAppCloudStatus::k_EAppCloudStatusInvalid,
        }
    }

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

    pub fn has_cloud_status(&self) -> bool {
        self.cloud_status.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.clientid = ::std::option::Option::Some(is.read_uint64()?);
                },
                18 => {
                    self.client_name = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.display_status = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                32 => {
                    self.status_percentage = ::std::option::Option::Some(is.read_uint32()?);
                },
                42 => {
                    self.active_beta = ::std::option::Option::Some(is.read_string()?);
                },
                48 => {
                    self.installed = ::std::option::Option::Some(is.read_bool()?);
                },
                56 => {
                    self.bytes_downloaded = ::std::option::Option::Some(is.read_uint64()?);
                },
                64 => {
                    self.bytes_total = ::std::option::Option::Some(is.read_uint64()?);
                },
                72 => {
                    self.streaming_to_local_client = ::std::option::Option::Some(is.read_bool()?);
                },
                80 => {
                    self.is_available_on_current_platform = ::std::option::Option::Some(is.read_bool()?);
                },
                88 => {
                    self.is_invalid_os_type = ::std::option::Option::Some(is.read_bool()?);
                },
                96 => {
                    self.playtime_left = ::std::option::Option::Some(is.read_uint32()?);
                },
                104 => {
                    self.cloud_status = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                tag => {
                    ::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.clientid {
            my_size += ::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.client_name.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.display_status {
            my_size += ::protobuf::rt::int32_size(3, v.value());
        }
        if let Some(v) = self.status_percentage {
            my_size += ::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.active_beta.as_ref() {
            my_size += ::protobuf::rt::string_size(5, &v);
        }
        if let Some(v) = self.installed {
            my_size += 1 + 1;
        }
        if let Some(v) = self.bytes_downloaded {
            my_size += ::protobuf::rt::uint64_size(7, v);
        }
        if let Some(v) = self.bytes_total {
            my_size += ::protobuf::rt::uint64_size(8, v);
        }
        if let Some(v) = self.streaming_to_local_client {
            my_size += 1 + 1;
        }
        if let Some(v) = self.is_available_on_current_platform {
            my_size += 1 + 1;
        }
        if let Some(v) = self.is_invalid_os_type {
            my_size += 1 + 1;
        }
        if let Some(v) = self.playtime_left {
            my_size += ::protobuf::rt::uint32_size(12, v);
        }
        if let Some(v) = self.cloud_status {
            my_size += ::protobuf::rt::int32_size(13, v.value());
        }
        my_size += ::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 ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.clientid {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.client_name.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.display_status {
            os.write_enum(3, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.status_percentage {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.active_beta.as_ref() {
            os.write_string(5, v)?;
        }
        if let Some(v) = self.installed {
            os.write_bool(6, v)?;
        }
        if let Some(v) = self.bytes_downloaded {
            os.write_uint64(7, v)?;
        }
        if let Some(v) = self.bytes_total {
            os.write_uint64(8, v)?;
        }
        if let Some(v) = self.streaming_to_local_client {
            os.write_bool(9, v)?;
        }
        if let Some(v) = self.is_available_on_current_platform {
            os.write_bool(10, v)?;
        }
        if let Some(v) = self.is_invalid_os_type {
            os.write_bool(11, v)?;
        }
        if let Some(v) = self.playtime_left {
            os.write_uint32(12, v)?;
        }
        if let Some(v) = self.cloud_status {
            os.write_enum(13, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.clientid = ::std::option::Option::None;
        self.client_name = ::std::option::Option::None;
        self.display_status = ::std::option::Option::None;
        self.status_percentage = ::std::option::Option::None;
        self.active_beta = ::std::option::Option::None;
        self.installed = ::std::option::Option::None;
        self.bytes_downloaded = ::std::option::Option::None;
        self.bytes_total = ::std::option::Option::None;
        self.streaming_to_local_client = ::std::option::Option::None;
        self.is_available_on_current_platform = ::std::option::Option::None;
        self.is_invalid_os_type = ::std::option::Option::None;
        self.playtime_left = ::std::option::Option::None;
        self.cloud_status = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CAppOverview_PerClientData {
        static instance: CAppOverview_PerClientData = CAppOverview_PerClientData {
            clientid: ::std::option::Option::None,
            client_name: ::std::option::Option::None,
            display_status: ::std::option::Option::None,
            status_percentage: ::std::option::Option::None,
            active_beta: ::std::option::Option::None,
            installed: ::std::option::Option::None,
            bytes_downloaded: ::std::option::Option::None,
            bytes_total: ::std::option::Option::None,
            streaming_to_local_client: ::std::option::Option::None,
            is_available_on_current_platform: ::std::option::Option::None,
            is_invalid_os_type: ::std::option::Option::None,
            playtime_left: ::std::option::Option::None,
            cloud_status: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CAppOverview)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CAppOverview {
    // message fields
    // @@protoc_insertion_point(field:CAppOverview.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.display_name)
    pub display_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CAppOverview.visible_in_game_list)
    pub visible_in_game_list: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CAppOverview.sort_as)
    pub sort_as: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CAppOverview.app_type)
    pub app_type: ::std::option::Option<::protobuf::EnumOrUnknown<EProtoAppType>>,
    // @@protoc_insertion_point(field:CAppOverview.mru_index)
    pub mru_index: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.rt_recent_activity_time)
    pub rt_recent_activity_time: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.minutes_playtime_forever)
    pub minutes_playtime_forever: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.minutes_playtime_last_two_weeks)
    pub minutes_playtime_last_two_weeks: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.rt_last_time_played)
    pub rt_last_time_played: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.store_tag)
    pub store_tag: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CAppOverview.association)
    pub association: ::std::vec::Vec<CAppOverview_AppAssociation>,
    // @@protoc_insertion_point(field:CAppOverview.store_category)
    pub store_category: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CAppOverview.rt_original_release_date)
    pub rt_original_release_date: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.rt_steam_release_date)
    pub rt_steam_release_date: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.icon_hash)
    pub icon_hash: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CAppOverview.controller_support)
    pub controller_support: ::std::option::Option<::protobuf::EnumOrUnknown<EAppControllerSupportLevel>>,
    // @@protoc_insertion_point(field:CAppOverview.vr_supported)
    pub vr_supported: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CAppOverview.metacritic_score)
    pub metacritic_score: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.size_on_disk)
    pub size_on_disk: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CAppOverview.third_party_mod)
    pub third_party_mod: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CAppOverview.icon_data)
    pub icon_data: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CAppOverview.icon_data_format)
    pub icon_data_format: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CAppOverview.gameid)
    pub gameid: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CAppOverview.library_capsule_filename)
    pub library_capsule_filename: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CAppOverview.per_client_data)
    pub per_client_data: ::std::vec::Vec<CAppOverview_PerClientData>,
    // @@protoc_insertion_point(field:CAppOverview.most_available_clientid)
    pub most_available_clientid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CAppOverview.selected_clientid)
    pub selected_clientid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CAppOverview.rt_store_asset_mtime)
    pub rt_store_asset_mtime: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.rt_custom_image_mtime)
    pub rt_custom_image_mtime: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.optional_parent_app_id)
    pub optional_parent_app_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.owner_account_id)
    pub owner_account_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.review_score_with_bombs)
    pub review_score_with_bombs: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.review_percentage_with_bombs)
    pub review_percentage_with_bombs: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.review_score_without_bombs)
    pub review_score_without_bombs: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.review_percentage_without_bombs)
    pub review_percentage_without_bombs: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.library_id)
    pub library_id: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CAppOverview.vr_only)
    pub vr_only: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CAppOverview.mastersub_appid)
    pub mastersub_appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.mastersub_includedwith_logo)
    pub mastersub_includedwith_logo: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CAppOverview.site_license_site_name)
    pub site_license_site_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CAppOverview.shortcut_override_appid)
    pub shortcut_override_appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.steam_deck_compat_category)
    pub steam_deck_compat_category: ::std::option::Option<::protobuf::EnumOrUnknown<super::enums::ESteamDeckCompatibilityCategory>>,
    // @@protoc_insertion_point(field:CAppOverview.rt_last_time_locally_played)
    pub rt_last_time_locally_played: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.rt_purchased_time)
    pub rt_purchased_time: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppOverview.header_filename)
    pub header_filename: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CAppOverview.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional string display_name = 2;

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

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

    pub fn has_display_name(&self) -> bool {
        self.display_name.is_some()
    }

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

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

    // optional bool visible_in_game_list = 4;

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

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

    pub fn has_visible_in_game_list(&self) -> bool {
        self.visible_in_game_list.is_some()
    }

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

    // optional string sort_as = 6;

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

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

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

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

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

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

    // optional .EProtoAppType app_type = 7;

    pub fn app_type(&self) -> EProtoAppType {
        match self.app_type {
            Some(e) => e.enum_value_or(EProtoAppType::k_EAppTypeInvalid),
            None => EProtoAppType::k_EAppTypeInvalid,
        }
    }

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

    pub fn has_app_type(&self) -> bool {
        self.app_type.is_some()
    }

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

    // optional uint32 mru_index = 13;

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

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

    pub fn has_mru_index(&self) -> bool {
        self.mru_index.is_some()
    }

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

    // optional uint32 rt_recent_activity_time = 14;

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

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

    pub fn has_rt_recent_activity_time(&self) -> bool {
        self.rt_recent_activity_time.is_some()
    }

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

    // optional uint32 minutes_playtime_forever = 16;

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

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

    pub fn has_minutes_playtime_forever(&self) -> bool {
        self.minutes_playtime_forever.is_some()
    }

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

    // optional uint32 minutes_playtime_last_two_weeks = 17;

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

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

    pub fn has_minutes_playtime_last_two_weeks(&self) -> bool {
        self.minutes_playtime_last_two_weeks.is_some()
    }

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

    // optional uint32 rt_last_time_played = 18;

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

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

    pub fn has_rt_last_time_played(&self) -> bool {
        self.rt_last_time_played.is_some()
    }

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

    // optional uint32 rt_original_release_date = 25;

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

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

    pub fn has_rt_original_release_date(&self) -> bool {
        self.rt_original_release_date.is_some()
    }

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

    // optional uint32 rt_steam_release_date = 26;

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

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

    pub fn has_rt_steam_release_date(&self) -> bool {
        self.rt_steam_release_date.is_some()
    }

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

    // optional string icon_hash = 27;

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

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

    pub fn has_icon_hash(&self) -> bool {
        self.icon_hash.is_some()
    }

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

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

    // optional .EAppControllerSupportLevel controller_support = 31;

    pub fn controller_support(&self) -> EAppControllerSupportLevel {
        match self.controller_support {
            Some(e) => e.enum_value_or(EAppControllerSupportLevel::k_EAppControllerSupportLevelNone),
            None => EAppControllerSupportLevel::k_EAppControllerSupportLevelNone,
        }
    }

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

    pub fn has_controller_support(&self) -> bool {
        self.controller_support.is_some()
    }

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

    // optional bool vr_supported = 32;

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

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

    pub fn has_vr_supported(&self) -> bool {
        self.vr_supported.is_some()
    }

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

    // optional uint32 metacritic_score = 36;

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

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

    pub fn has_metacritic_score(&self) -> bool {
        self.metacritic_score.is_some()
    }

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

    // optional uint64 size_on_disk = 37;

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

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

    pub fn has_size_on_disk(&self) -> bool {
        self.size_on_disk.is_some()
    }

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

    // optional bool third_party_mod = 38;

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

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

    pub fn has_third_party_mod(&self) -> bool {
        self.third_party_mod.is_some()
    }

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

    // optional string icon_data = 39;

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

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

    pub fn has_icon_data(&self) -> bool {
        self.icon_data.is_some()
    }

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

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

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

    // optional string icon_data_format = 40;

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

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

    pub fn has_icon_data_format(&self) -> bool {
        self.icon_data_format.is_some()
    }

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

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

    // optional string gameid = 41;

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

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

    pub fn has_gameid(&self) -> bool {
        self.gameid.is_some()
    }

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

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

    // optional string library_capsule_filename = 42;

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

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

    pub fn has_library_capsule_filename(&self) -> bool {
        self.library_capsule_filename.is_some()
    }

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

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

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

    // optional uint64 most_available_clientid = 44;

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

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

    pub fn has_most_available_clientid(&self) -> bool {
        self.most_available_clientid.is_some()
    }

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

    // optional uint64 selected_clientid = 45;

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

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

    pub fn has_selected_clientid(&self) -> bool {
        self.selected_clientid.is_some()
    }

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

    // optional uint32 rt_store_asset_mtime = 46;

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

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

    pub fn has_rt_store_asset_mtime(&self) -> bool {
        self.rt_store_asset_mtime.is_some()
    }

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

    // optional uint32 rt_custom_image_mtime = 47;

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

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

    pub fn has_rt_custom_image_mtime(&self) -> bool {
        self.rt_custom_image_mtime.is_some()
    }

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

    // optional uint32 optional_parent_app_id = 48;

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

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

    pub fn has_optional_parent_app_id(&self) -> bool {
        self.optional_parent_app_id.is_some()
    }

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

    // optional uint32 owner_account_id = 49;

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

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

    pub fn has_owner_account_id(&self) -> bool {
        self.owner_account_id.is_some()
    }

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

    // optional uint32 review_score_with_bombs = 53;

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

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

    pub fn has_review_score_with_bombs(&self) -> bool {
        self.review_score_with_bombs.is_some()
    }

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

    // optional uint32 review_percentage_with_bombs = 54;

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

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

    pub fn has_review_percentage_with_bombs(&self) -> bool {
        self.review_percentage_with_bombs.is_some()
    }

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

    // optional uint32 review_score_without_bombs = 55;

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

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

    pub fn has_review_score_without_bombs(&self) -> bool {
        self.review_score_without_bombs.is_some()
    }

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

    // optional uint32 review_percentage_without_bombs = 56;

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

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

    pub fn has_review_percentage_without_bombs(&self) -> bool {
        self.review_percentage_without_bombs.is_some()
    }

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

    // optional string library_id = 57;

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

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

    pub fn has_library_id(&self) -> bool {
        self.library_id.is_some()
    }

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

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

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

    // optional bool vr_only = 58;

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

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

    pub fn has_vr_only(&self) -> bool {
        self.vr_only.is_some()
    }

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

    // optional uint32 mastersub_appid = 59;

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

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

    pub fn has_mastersub_appid(&self) -> bool {
        self.mastersub_appid.is_some()
    }

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

    // optional string mastersub_includedwith_logo = 60;

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

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

    pub fn has_mastersub_includedwith_logo(&self) -> bool {
        self.mastersub_includedwith_logo.is_some()
    }

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

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

    // optional string site_license_site_name = 62;

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

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

    pub fn has_site_license_site_name(&self) -> bool {
        self.site_license_site_name.is_some()
    }

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

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

    // optional uint32 shortcut_override_appid = 63;

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

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

    pub fn has_shortcut_override_appid(&self) -> bool {
        self.shortcut_override_appid.is_some()
    }

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

    // optional .ESteamDeckCompatibilityCategory steam_deck_compat_category = 64;

    pub fn steam_deck_compat_category(&self) -> super::enums::ESteamDeckCompatibilityCategory {
        match self.steam_deck_compat_category {
            Some(e) => e.enum_value_or(super::enums::ESteamDeckCompatibilityCategory::k_ESteamDeckCompatibilityCategory_Unknown),
            None => super::enums::ESteamDeckCompatibilityCategory::k_ESteamDeckCompatibilityCategory_Unknown,
        }
    }

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

    pub fn has_steam_deck_compat_category(&self) -> bool {
        self.steam_deck_compat_category.is_some()
    }

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

    // optional uint32 rt_last_time_locally_played = 65;

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

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

    pub fn has_rt_last_time_locally_played(&self) -> bool {
        self.rt_last_time_locally_played.is_some()
    }

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

    // optional uint32 rt_purchased_time = 66;

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

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

    pub fn has_rt_purchased_time(&self) -> bool {
        self.rt_purchased_time.is_some()
    }

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

    // optional string header_filename = 67;

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

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

    pub fn has_header_filename(&self) -> bool {
        self.header_filename.is_some()
    }

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                18 => {
                    self.display_name = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.visible_in_game_list = ::std::option::Option::Some(is.read_bool()?);
                },
                50 => {
                    self.sort_as = ::std::option::Option::Some(is.read_string()?);
                },
                56 => {
                    self.app_type = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                104 => {
                    self.mru_index = ::std::option::Option::Some(is.read_uint32()?);
                },
                112 => {
                    self.rt_recent_activity_time = ::std::option::Option::Some(is.read_uint32()?);
                },
                128 => {
                    self.minutes_playtime_forever = ::std::option::Option::Some(is.read_uint32()?);
                },
                136 => {
                    self.minutes_playtime_last_two_weeks = ::std::option::Option::Some(is.read_uint32()?);
                },
                144 => {
                    self.rt_last_time_played = ::std::option::Option::Some(is.read_uint32()?);
                },
                154 => {
                    is.read_repeated_packed_uint32_into(&mut self.store_tag)?;
                },
                152 => {
                    self.store_tag.push(is.read_uint32()?);
                },
                162 => {
                    self.association.push(is.read_message()?);
                },
                186 => {
                    is.read_repeated_packed_uint32_into(&mut self.store_category)?;
                },
                184 => {
                    self.store_category.push(is.read_uint32()?);
                },
                200 => {
                    self.rt_original_release_date = ::std::option::Option::Some(is.read_uint32()?);
                },
                208 => {
                    self.rt_steam_release_date = ::std::option::Option::Some(is.read_uint32()?);
                },
                218 => {
                    self.icon_hash = ::std::option::Option::Some(is.read_string()?);
                },
                248 => {
                    self.controller_support = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                256 => {
                    self.vr_supported = ::std::option::Option::Some(is.read_bool()?);
                },
                288 => {
                    self.metacritic_score = ::std::option::Option::Some(is.read_uint32()?);
                },
                296 => {
                    self.size_on_disk = ::std::option::Option::Some(is.read_uint64()?);
                },
                304 => {
                    self.third_party_mod = ::std::option::Option::Some(is.read_bool()?);
                },
                314 => {
                    self.icon_data = ::std::option::Option::Some(is.read_string()?);
                },
                322 => {
                    self.icon_data_format = ::std::option::Option::Some(is.read_string()?);
                },
                330 => {
                    self.gameid = ::std::option::Option::Some(is.read_string()?);
                },
                338 => {
                    self.library_capsule_filename = ::std::option::Option::Some(is.read_string()?);
                },
                346 => {
                    self.per_client_data.push(is.read_message()?);
                },
                352 => {
                    self.most_available_clientid = ::std::option::Option::Some(is.read_uint64()?);
                },
                360 => {
                    self.selected_clientid = ::std::option::Option::Some(is.read_uint64()?);
                },
                368 => {
                    self.rt_store_asset_mtime = ::std::option::Option::Some(is.read_uint32()?);
                },
                376 => {
                    self.rt_custom_image_mtime = ::std::option::Option::Some(is.read_uint32()?);
                },
                384 => {
                    self.optional_parent_app_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                392 => {
                    self.owner_account_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                424 => {
                    self.review_score_with_bombs = ::std::option::Option::Some(is.read_uint32()?);
                },
                432 => {
                    self.review_percentage_with_bombs = ::std::option::Option::Some(is.read_uint32()?);
                },
                440 => {
                    self.review_score_without_bombs = ::std::option::Option::Some(is.read_uint32()?);
                },
                448 => {
                    self.review_percentage_without_bombs = ::std::option::Option::Some(is.read_uint32()?);
                },
                458 => {
                    self.library_id = ::std::option::Option::Some(is.read_string()?);
                },
                464 => {
                    self.vr_only = ::std::option::Option::Some(is.read_bool()?);
                },
                472 => {
                    self.mastersub_appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                482 => {
                    self.mastersub_includedwith_logo = ::std::option::Option::Some(is.read_string()?);
                },
                498 => {
                    self.site_license_site_name = ::std::option::Option::Some(is.read_string()?);
                },
                504 => {
                    self.shortcut_override_appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                512 => {
                    self.steam_deck_compat_category = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                520 => {
                    self.rt_last_time_locally_played = ::std::option::Option::Some(is.read_uint32()?);
                },
                528 => {
                    self.rt_purchased_time = ::std::option::Option::Some(is.read_uint32()?);
                },
                538 => {
                    self.header_filename = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.display_name.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.visible_in_game_list {
            my_size += 1 + 1;
        }
        if let Some(v) = self.sort_as.as_ref() {
            my_size += ::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.app_type {
            my_size += ::protobuf::rt::int32_size(7, v.value());
        }
        if let Some(v) = self.mru_index {
            my_size += ::protobuf::rt::uint32_size(13, v);
        }
        if let Some(v) = self.rt_recent_activity_time {
            my_size += ::protobuf::rt::uint32_size(14, v);
        }
        if let Some(v) = self.minutes_playtime_forever {
            my_size += ::protobuf::rt::uint32_size(16, v);
        }
        if let Some(v) = self.minutes_playtime_last_two_weeks {
            my_size += ::protobuf::rt::uint32_size(17, v);
        }
        if let Some(v) = self.rt_last_time_played {
            my_size += ::protobuf::rt::uint32_size(18, v);
        }
        for value in &self.store_tag {
            my_size += ::protobuf::rt::uint32_size(19, *value);
        };
        for value in &self.association {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.store_category {
            my_size += ::protobuf::rt::uint32_size(23, *value);
        };
        if let Some(v) = self.rt_original_release_date {
            my_size += ::protobuf::rt::uint32_size(25, v);
        }
        if let Some(v) = self.rt_steam_release_date {
            my_size += ::protobuf::rt::uint32_size(26, v);
        }
        if let Some(v) = self.icon_hash.as_ref() {
            my_size += ::protobuf::rt::string_size(27, &v);
        }
        if let Some(v) = self.controller_support {
            my_size += ::protobuf::rt::int32_size(31, v.value());
        }
        if let Some(v) = self.vr_supported {
            my_size += 2 + 1;
        }
        if let Some(v) = self.metacritic_score {
            my_size += ::protobuf::rt::uint32_size(36, v);
        }
        if let Some(v) = self.size_on_disk {
            my_size += ::protobuf::rt::uint64_size(37, v);
        }
        if let Some(v) = self.third_party_mod {
            my_size += 2 + 1;
        }
        if let Some(v) = self.icon_data.as_ref() {
            my_size += ::protobuf::rt::string_size(39, &v);
        }
        if let Some(v) = self.icon_data_format.as_ref() {
            my_size += ::protobuf::rt::string_size(40, &v);
        }
        if let Some(v) = self.gameid.as_ref() {
            my_size += ::protobuf::rt::string_size(41, &v);
        }
        if let Some(v) = self.library_capsule_filename.as_ref() {
            my_size += ::protobuf::rt::string_size(42, &v);
        }
        for value in &self.per_client_data {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.most_available_clientid {
            my_size += ::protobuf::rt::uint64_size(44, v);
        }
        if let Some(v) = self.selected_clientid {
            my_size += ::protobuf::rt::uint64_size(45, v);
        }
        if let Some(v) = self.rt_store_asset_mtime {
            my_size += ::protobuf::rt::uint32_size(46, v);
        }
        if let Some(v) = self.rt_custom_image_mtime {
            my_size += ::protobuf::rt::uint32_size(47, v);
        }
        if let Some(v) = self.optional_parent_app_id {
            my_size += ::protobuf::rt::uint32_size(48, v);
        }
        if let Some(v) = self.owner_account_id {
            my_size += ::protobuf::rt::uint32_size(49, v);
        }
        if let Some(v) = self.review_score_with_bombs {
            my_size += ::protobuf::rt::uint32_size(53, v);
        }
        if let Some(v) = self.review_percentage_with_bombs {
            my_size += ::protobuf::rt::uint32_size(54, v);
        }
        if let Some(v) = self.review_score_without_bombs {
            my_size += ::protobuf::rt::uint32_size(55, v);
        }
        if let Some(v) = self.review_percentage_without_bombs {
            my_size += ::protobuf::rt::uint32_size(56, v);
        }
        if let Some(v) = self.library_id.as_ref() {
            my_size += ::protobuf::rt::string_size(57, &v);
        }
        if let Some(v) = self.vr_only {
            my_size += 2 + 1;
        }
        if let Some(v) = self.mastersub_appid {
            my_size += ::protobuf::rt::uint32_size(59, v);
        }
        if let Some(v) = self.mastersub_includedwith_logo.as_ref() {
            my_size += ::protobuf::rt::string_size(60, &v);
        }
        if let Some(v) = self.site_license_site_name.as_ref() {
            my_size += ::protobuf::rt::string_size(62, &v);
        }
        if let Some(v) = self.shortcut_override_appid {
            my_size += ::protobuf::rt::uint32_size(63, v);
        }
        if let Some(v) = self.steam_deck_compat_category {
            my_size += ::protobuf::rt::int32_size(64, v.value());
        }
        if let Some(v) = self.rt_last_time_locally_played {
            my_size += ::protobuf::rt::uint32_size(65, v);
        }
        if let Some(v) = self.rt_purchased_time {
            my_size += ::protobuf::rt::uint32_size(66, v);
        }
        if let Some(v) = self.header_filename.as_ref() {
            my_size += ::protobuf::rt::string_size(67, &v);
        }
        my_size += ::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 ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.display_name.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.visible_in_game_list {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.sort_as.as_ref() {
            os.write_string(6, v)?;
        }
        if let Some(v) = self.app_type {
            os.write_enum(7, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.mru_index {
            os.write_uint32(13, v)?;
        }
        if let Some(v) = self.rt_recent_activity_time {
            os.write_uint32(14, v)?;
        }
        if let Some(v) = self.minutes_playtime_forever {
            os.write_uint32(16, v)?;
        }
        if let Some(v) = self.minutes_playtime_last_two_weeks {
            os.write_uint32(17, v)?;
        }
        if let Some(v) = self.rt_last_time_played {
            os.write_uint32(18, v)?;
        }
        for v in &self.store_tag {
            os.write_uint32(19, *v)?;
        };
        for v in &self.association {
            ::protobuf::rt::write_message_field_with_cached_size(20, v, os)?;
        };
        for v in &self.store_category {
            os.write_uint32(23, *v)?;
        };
        if let Some(v) = self.rt_original_release_date {
            os.write_uint32(25, v)?;
        }
        if let Some(v) = self.rt_steam_release_date {
            os.write_uint32(26, v)?;
        }
        if let Some(v) = self.icon_hash.as_ref() {
            os.write_string(27, v)?;
        }
        if let Some(v) = self.controller_support {
            os.write_enum(31, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.vr_supported {
            os.write_bool(32, v)?;
        }
        if let Some(v) = self.metacritic_score {
            os.write_uint32(36, v)?;
        }
        if let Some(v) = self.size_on_disk {
            os.write_uint64(37, v)?;
        }
        if let Some(v) = self.third_party_mod {
            os.write_bool(38, v)?;
        }
        if let Some(v) = self.icon_data.as_ref() {
            os.write_string(39, v)?;
        }
        if let Some(v) = self.icon_data_format.as_ref() {
            os.write_string(40, v)?;
        }
        if let Some(v) = self.gameid.as_ref() {
            os.write_string(41, v)?;
        }
        if let Some(v) = self.library_capsule_filename.as_ref() {
            os.write_string(42, v)?;
        }
        for v in &self.per_client_data {
            ::protobuf::rt::write_message_field_with_cached_size(43, v, os)?;
        };
        if let Some(v) = self.most_available_clientid {
            os.write_uint64(44, v)?;
        }
        if let Some(v) = self.selected_clientid {
            os.write_uint64(45, v)?;
        }
        if let Some(v) = self.rt_store_asset_mtime {
            os.write_uint32(46, v)?;
        }
        if let Some(v) = self.rt_custom_image_mtime {
            os.write_uint32(47, v)?;
        }
        if let Some(v) = self.optional_parent_app_id {
            os.write_uint32(48, v)?;
        }
        if let Some(v) = self.owner_account_id {
            os.write_uint32(49, v)?;
        }
        if let Some(v) = self.review_score_with_bombs {
            os.write_uint32(53, v)?;
        }
        if let Some(v) = self.review_percentage_with_bombs {
            os.write_uint32(54, v)?;
        }
        if let Some(v) = self.review_score_without_bombs {
            os.write_uint32(55, v)?;
        }
        if let Some(v) = self.review_percentage_without_bombs {
            os.write_uint32(56, v)?;
        }
        if let Some(v) = self.library_id.as_ref() {
            os.write_string(57, v)?;
        }
        if let Some(v) = self.vr_only {
            os.write_bool(58, v)?;
        }
        if let Some(v) = self.mastersub_appid {
            os.write_uint32(59, v)?;
        }
        if let Some(v) = self.mastersub_includedwith_logo.as_ref() {
            os.write_string(60, v)?;
        }
        if let Some(v) = self.site_license_site_name.as_ref() {
            os.write_string(62, v)?;
        }
        if let Some(v) = self.shortcut_override_appid {
            os.write_uint32(63, v)?;
        }
        if let Some(v) = self.steam_deck_compat_category {
            os.write_enum(64, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.rt_last_time_locally_played {
            os.write_uint32(65, v)?;
        }
        if let Some(v) = self.rt_purchased_time {
            os.write_uint32(66, v)?;
        }
        if let Some(v) = self.header_filename.as_ref() {
            os.write_string(67, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.display_name = ::std::option::Option::None;
        self.visible_in_game_list = ::std::option::Option::None;
        self.sort_as = ::std::option::Option::None;
        self.app_type = ::std::option::Option::None;
        self.mru_index = ::std::option::Option::None;
        self.rt_recent_activity_time = ::std::option::Option::None;
        self.minutes_playtime_forever = ::std::option::Option::None;
        self.minutes_playtime_last_two_weeks = ::std::option::Option::None;
        self.rt_last_time_played = ::std::option::Option::None;
        self.store_tag.clear();
        self.association.clear();
        self.store_category.clear();
        self.rt_original_release_date = ::std::option::Option::None;
        self.rt_steam_release_date = ::std::option::Option::None;
        self.icon_hash = ::std::option::Option::None;
        self.controller_support = ::std::option::Option::None;
        self.vr_supported = ::std::option::Option::None;
        self.metacritic_score = ::std::option::Option::None;
        self.size_on_disk = ::std::option::Option::None;
        self.third_party_mod = ::std::option::Option::None;
        self.icon_data = ::std::option::Option::None;
        self.icon_data_format = ::std::option::Option::None;
        self.gameid = ::std::option::Option::None;
        self.library_capsule_filename = ::std::option::Option::None;
        self.per_client_data.clear();
        self.most_available_clientid = ::std::option::Option::None;
        self.selected_clientid = ::std::option::Option::None;
        self.rt_store_asset_mtime = ::std::option::Option::None;
        self.rt_custom_image_mtime = ::std::option::Option::None;
        self.optional_parent_app_id = ::std::option::Option::None;
        self.owner_account_id = ::std::option::Option::None;
        self.review_score_with_bombs = ::std::option::Option::None;
        self.review_percentage_with_bombs = ::std::option::Option::None;
        self.review_score_without_bombs = ::std::option::Option::None;
        self.review_percentage_without_bombs = ::std::option::Option::None;
        self.library_id = ::std::option::Option::None;
        self.vr_only = ::std::option::Option::None;
        self.mastersub_appid = ::std::option::Option::None;
        self.mastersub_includedwith_logo = ::std::option::Option::None;
        self.site_license_site_name = ::std::option::Option::None;
        self.shortcut_override_appid = ::std::option::Option::None;
        self.steam_deck_compat_category = ::std::option::Option::None;
        self.rt_last_time_locally_played = ::std::option::Option::None;
        self.rt_purchased_time = ::std::option::Option::None;
        self.header_filename = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CAppOverview {
        static instance: CAppOverview = CAppOverview {
            appid: ::std::option::Option::None,
            display_name: ::std::option::Option::None,
            visible_in_game_list: ::std::option::Option::None,
            sort_as: ::std::option::Option::None,
            app_type: ::std::option::Option::None,
            mru_index: ::std::option::Option::None,
            rt_recent_activity_time: ::std::option::Option::None,
            minutes_playtime_forever: ::std::option::Option::None,
            minutes_playtime_last_two_weeks: ::std::option::Option::None,
            rt_last_time_played: ::std::option::Option::None,
            store_tag: ::std::vec::Vec::new(),
            association: ::std::vec::Vec::new(),
            store_category: ::std::vec::Vec::new(),
            rt_original_release_date: ::std::option::Option::None,
            rt_steam_release_date: ::std::option::Option::None,
            icon_hash: ::std::option::Option::None,
            controller_support: ::std::option::Option::None,
            vr_supported: ::std::option::Option::None,
            metacritic_score: ::std::option::Option::None,
            size_on_disk: ::std::option::Option::None,
            third_party_mod: ::std::option::Option::None,
            icon_data: ::std::option::Option::None,
            icon_data_format: ::std::option::Option::None,
            gameid: ::std::option::Option::None,
            library_capsule_filename: ::std::option::Option::None,
            per_client_data: ::std::vec::Vec::new(),
            most_available_clientid: ::std::option::Option::None,
            selected_clientid: ::std::option::Option::None,
            rt_store_asset_mtime: ::std::option::Option::None,
            rt_custom_image_mtime: ::std::option::Option::None,
            optional_parent_app_id: ::std::option::Option::None,
            owner_account_id: ::std::option::Option::None,
            review_score_with_bombs: ::std::option::Option::None,
            review_percentage_with_bombs: ::std::option::Option::None,
            review_score_without_bombs: ::std::option::Option::None,
            review_percentage_without_bombs: ::std::option::Option::None,
            library_id: ::std::option::Option::None,
            vr_only: ::std::option::Option::None,
            mastersub_appid: ::std::option::Option::None,
            mastersub_includedwith_logo: ::std::option::Option::None,
            site_license_site_name: ::std::option::Option::None,
            shortcut_override_appid: ::std::option::Option::None,
            steam_deck_compat_category: ::std::option::Option::None,
            rt_last_time_locally_played: ::std::option::Option::None,
            rt_purchased_time: ::std::option::Option::None,
            header_filename: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CAppOverview_Change)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CAppOverview_Change {
    // message fields
    // @@protoc_insertion_point(field:CAppOverview_Change.app_overview)
    pub app_overview: ::std::vec::Vec<CAppOverview>,
    // @@protoc_insertion_point(field:CAppOverview_Change.removed_appid)
    pub removed_appid: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CAppOverview_Change.full_update)
    pub full_update: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CAppOverview_Change.update_complete)
    pub update_complete: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CAppOverview_Change.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional bool full_update = 3;

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

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

    pub fn has_full_update(&self) -> bool {
        self.full_update.is_some()
    }

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

    // optional bool update_complete = 4;

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

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

    pub fn has_update_complete(&self) -> bool {
        self.update_complete.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.app_overview.push(is.read_message()?);
                },
                18 => {
                    is.read_repeated_packed_uint32_into(&mut self.removed_appid)?;
                },
                16 => {
                    self.removed_appid.push(is.read_uint32()?);
                },
                24 => {
                    self.full_update = ::std::option::Option::Some(is.read_bool()?);
                },
                32 => {
                    self.update_complete = ::std::option::Option::Some(is.read_bool()?);
                },
                tag => {
                    ::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_overview {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.removed_appid {
            my_size += ::protobuf::rt::uint32_size(2, *value);
        };
        if let Some(v) = self.full_update {
            my_size += 1 + 1;
        }
        if let Some(v) = self.update_complete {
            my_size += 1 + 1;
        }
        my_size += ::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 ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        for v in &self.app_overview {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        for v in &self.removed_appid {
            os.write_uint32(2, *v)?;
        };
        if let Some(v) = self.full_update {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.update_complete {
            os.write_bool(4, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.app_overview.clear();
        self.removed_appid.clear();
        self.full_update = ::std::option::Option::None;
        self.update_complete = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CAppOverview_Change {
        static instance: CAppOverview_Change = CAppOverview_Change {
            app_overview: ::std::vec::Vec::new(),
            removed_appid: ::std::vec::Vec::new(),
            full_update: ::std::option::Option::None,
            update_complete: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CAppBootstrapData)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CAppBootstrapData {
    // message fields
    // @@protoc_insertion_point(field:CAppBootstrapData.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CAppBootstrapData.hidden)
    pub hidden: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CAppBootstrapData.user_tag)
    pub user_tag: ::std::vec::Vec<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CAppBootstrapData.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional bool hidden = 2;

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

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

    pub fn has_hidden(&self) -> bool {
        self.hidden.is_some()
    }

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

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

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

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

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.hidden {
            my_size += 1 + 1;
        }
        for value in &self.user_tag {
            my_size += ::protobuf::rt::string_size(3, &value);
        };
        my_size += ::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 ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.hidden {
            os.write_bool(2, v)?;
        }
        for v in &self.user_tag {
            os.write_string(3, &v)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

    fn default_instance() -> &'static CAppBootstrapData {
        static instance: CAppBootstrapData = CAppBootstrapData {
            appid: ::std::option::Option::None,
            hidden: ::std::option::Option::None,
            user_tag: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.app_data.push(is.read_message()?);
                },
                tag => {
                    ::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_data {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::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 ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        for v in &self.app_data {
            ::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) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

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

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

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

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

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:EDisplayStatus)
pub enum EDisplayStatus {
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusInvalid)
    k_EDisplayStatusInvalid = 0,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusLaunching)
    k_EDisplayStatusLaunching = 1,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusUninstalling)
    k_EDisplayStatusUninstalling = 2,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusInstalling)
    k_EDisplayStatusInstalling = 3,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusRunning)
    k_EDisplayStatusRunning = 4,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusValidating)
    k_EDisplayStatusValidating = 5,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusUpdating)
    k_EDisplayStatusUpdating = 6,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusDownloading)
    k_EDisplayStatusDownloading = 7,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusSynchronizing)
    k_EDisplayStatusSynchronizing = 8,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusReadyToInstall)
    k_EDisplayStatusReadyToInstall = 9,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusReadyToPreload)
    k_EDisplayStatusReadyToPreload = 10,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusReadyToLaunch)
    k_EDisplayStatusReadyToLaunch = 11,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusRegionRestricted)
    k_EDisplayStatusRegionRestricted = 12,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusPresaleOnly)
    k_EDisplayStatusPresaleOnly = 13,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusInvalidPlatform)
    k_EDisplayStatusInvalidPlatform = 14,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusPreloadComplete)
    k_EDisplayStatusPreloadComplete = 16,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusBorrowerLocked)
    k_EDisplayStatusBorrowerLocked = 17,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusUpdatePaused)
    k_EDisplayStatusUpdatePaused = 18,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusUpdateQueued)
    k_EDisplayStatusUpdateQueued = 19,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusUpdateRequired)
    k_EDisplayStatusUpdateRequired = 20,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusUpdateDisabled)
    k_EDisplayStatusUpdateDisabled = 21,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusDownloadPaused)
    k_EDisplayStatusDownloadPaused = 22,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusDownloadQueued)
    k_EDisplayStatusDownloadQueued = 23,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusDownloadRequired)
    k_EDisplayStatusDownloadRequired = 24,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusDownloadDisabled)
    k_EDisplayStatusDownloadDisabled = 25,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusLicensePending)
    k_EDisplayStatusLicensePending = 26,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusLicenseExpired)
    k_EDisplayStatusLicenseExpired = 27,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusAvailForFree)
    k_EDisplayStatusAvailForFree = 28,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusAvailToBorrow)
    k_EDisplayStatusAvailToBorrow = 29,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusAvailGuestPass)
    k_EDisplayStatusAvailGuestPass = 30,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusPurchase)
    k_EDisplayStatusPurchase = 31,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusUnavailable)
    k_EDisplayStatusUnavailable = 32,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusNotLaunchable)
    k_EDisplayStatusNotLaunchable = 33,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusCloudError)
    k_EDisplayStatusCloudError = 34,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusCloudOutOfDate)
    k_EDisplayStatusCloudOutOfDate = 35,
    // @@protoc_insertion_point(enum_value:EDisplayStatus.k_EDisplayStatusTerminating)
    k_EDisplayStatusTerminating = 36,
}

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

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

    fn from_i32(value: i32) -> ::std::option::Option<EDisplayStatus> {
        match value {
            0 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusInvalid),
            1 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusLaunching),
            2 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusUninstalling),
            3 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusInstalling),
            4 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusRunning),
            5 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusValidating),
            6 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusUpdating),
            7 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusDownloading),
            8 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusSynchronizing),
            9 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusReadyToInstall),
            10 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusReadyToPreload),
            11 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusReadyToLaunch),
            12 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusRegionRestricted),
            13 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusPresaleOnly),
            14 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusInvalidPlatform),
            16 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusPreloadComplete),
            17 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusBorrowerLocked),
            18 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusUpdatePaused),
            19 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusUpdateQueued),
            20 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusUpdateRequired),
            21 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusUpdateDisabled),
            22 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusDownloadPaused),
            23 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusDownloadQueued),
            24 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusDownloadRequired),
            25 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusDownloadDisabled),
            26 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusLicensePending),
            27 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusLicenseExpired),
            28 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusAvailForFree),
            29 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusAvailToBorrow),
            30 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusAvailGuestPass),
            31 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusPurchase),
            32 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusUnavailable),
            33 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusNotLaunchable),
            34 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusCloudError),
            35 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusCloudOutOfDate),
            36 => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusTerminating),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<EDisplayStatus> {
        match str {
            "k_EDisplayStatusInvalid" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusInvalid),
            "k_EDisplayStatusLaunching" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusLaunching),
            "k_EDisplayStatusUninstalling" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusUninstalling),
            "k_EDisplayStatusInstalling" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusInstalling),
            "k_EDisplayStatusRunning" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusRunning),
            "k_EDisplayStatusValidating" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusValidating),
            "k_EDisplayStatusUpdating" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusUpdating),
            "k_EDisplayStatusDownloading" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusDownloading),
            "k_EDisplayStatusSynchronizing" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusSynchronizing),
            "k_EDisplayStatusReadyToInstall" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusReadyToInstall),
            "k_EDisplayStatusReadyToPreload" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusReadyToPreload),
            "k_EDisplayStatusReadyToLaunch" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusReadyToLaunch),
            "k_EDisplayStatusRegionRestricted" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusRegionRestricted),
            "k_EDisplayStatusPresaleOnly" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusPresaleOnly),
            "k_EDisplayStatusInvalidPlatform" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusInvalidPlatform),
            "k_EDisplayStatusPreloadComplete" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusPreloadComplete),
            "k_EDisplayStatusBorrowerLocked" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusBorrowerLocked),
            "k_EDisplayStatusUpdatePaused" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusUpdatePaused),
            "k_EDisplayStatusUpdateQueued" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusUpdateQueued),
            "k_EDisplayStatusUpdateRequired" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusUpdateRequired),
            "k_EDisplayStatusUpdateDisabled" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusUpdateDisabled),
            "k_EDisplayStatusDownloadPaused" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusDownloadPaused),
            "k_EDisplayStatusDownloadQueued" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusDownloadQueued),
            "k_EDisplayStatusDownloadRequired" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusDownloadRequired),
            "k_EDisplayStatusDownloadDisabled" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusDownloadDisabled),
            "k_EDisplayStatusLicensePending" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusLicensePending),
            "k_EDisplayStatusLicenseExpired" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusLicenseExpired),
            "k_EDisplayStatusAvailForFree" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusAvailForFree),
            "k_EDisplayStatusAvailToBorrow" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusAvailToBorrow),
            "k_EDisplayStatusAvailGuestPass" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusAvailGuestPass),
            "k_EDisplayStatusPurchase" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusPurchase),
            "k_EDisplayStatusUnavailable" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusUnavailable),
            "k_EDisplayStatusNotLaunchable" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusNotLaunchable),
            "k_EDisplayStatusCloudError" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusCloudError),
            "k_EDisplayStatusCloudOutOfDate" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusCloudOutOfDate),
            "k_EDisplayStatusTerminating" => ::std::option::Option::Some(EDisplayStatus::k_EDisplayStatusTerminating),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [EDisplayStatus] = &[
        EDisplayStatus::k_EDisplayStatusInvalid,
        EDisplayStatus::k_EDisplayStatusLaunching,
        EDisplayStatus::k_EDisplayStatusUninstalling,
        EDisplayStatus::k_EDisplayStatusInstalling,
        EDisplayStatus::k_EDisplayStatusRunning,
        EDisplayStatus::k_EDisplayStatusValidating,
        EDisplayStatus::k_EDisplayStatusUpdating,
        EDisplayStatus::k_EDisplayStatusDownloading,
        EDisplayStatus::k_EDisplayStatusSynchronizing,
        EDisplayStatus::k_EDisplayStatusReadyToInstall,
        EDisplayStatus::k_EDisplayStatusReadyToPreload,
        EDisplayStatus::k_EDisplayStatusReadyToLaunch,
        EDisplayStatus::k_EDisplayStatusRegionRestricted,
        EDisplayStatus::k_EDisplayStatusPresaleOnly,
        EDisplayStatus::k_EDisplayStatusInvalidPlatform,
        EDisplayStatus::k_EDisplayStatusPreloadComplete,
        EDisplayStatus::k_EDisplayStatusBorrowerLocked,
        EDisplayStatus::k_EDisplayStatusUpdatePaused,
        EDisplayStatus::k_EDisplayStatusUpdateQueued,
        EDisplayStatus::k_EDisplayStatusUpdateRequired,
        EDisplayStatus::k_EDisplayStatusUpdateDisabled,
        EDisplayStatus::k_EDisplayStatusDownloadPaused,
        EDisplayStatus::k_EDisplayStatusDownloadQueued,
        EDisplayStatus::k_EDisplayStatusDownloadRequired,
        EDisplayStatus::k_EDisplayStatusDownloadDisabled,
        EDisplayStatus::k_EDisplayStatusLicensePending,
        EDisplayStatus::k_EDisplayStatusLicenseExpired,
        EDisplayStatus::k_EDisplayStatusAvailForFree,
        EDisplayStatus::k_EDisplayStatusAvailToBorrow,
        EDisplayStatus::k_EDisplayStatusAvailGuestPass,
        EDisplayStatus::k_EDisplayStatusPurchase,
        EDisplayStatus::k_EDisplayStatusUnavailable,
        EDisplayStatus::k_EDisplayStatusNotLaunchable,
        EDisplayStatus::k_EDisplayStatusCloudError,
        EDisplayStatus::k_EDisplayStatusCloudOutOfDate,
        EDisplayStatus::k_EDisplayStatusTerminating,
    ];
}

impl ::std::default::Default for EDisplayStatus {
    fn default() -> Self {
        EDisplayStatus::k_EDisplayStatusInvalid
    }
}


#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:EAppCloudStatus)
pub enum EAppCloudStatus {
    // @@protoc_insertion_point(enum_value:EAppCloudStatus.k_EAppCloudStatusInvalid)
    k_EAppCloudStatusInvalid = 0,
    // @@protoc_insertion_point(enum_value:EAppCloudStatus.k_EAppCloudStatusDisabled)
    k_EAppCloudStatusDisabled = 1,
    // @@protoc_insertion_point(enum_value:EAppCloudStatus.k_EAppCloudStatusUnknown)
    k_EAppCloudStatusUnknown = 2,
    // @@protoc_insertion_point(enum_value:EAppCloudStatus.k_EAppCloudStatusSynchronized)
    k_EAppCloudStatusSynchronized = 3,
    // @@protoc_insertion_point(enum_value:EAppCloudStatus.k_EAppCloudStatusChecking)
    k_EAppCloudStatusChecking = 4,
    // @@protoc_insertion_point(enum_value:EAppCloudStatus.k_EAppCloudStatusOutOfSync)
    k_EAppCloudStatusOutOfSync = 5,
    // @@protoc_insertion_point(enum_value:EAppCloudStatus.k_EAppCloudStatusUploading)
    k_EAppCloudStatusUploading = 6,
    // @@protoc_insertion_point(enum_value:EAppCloudStatus.k_EAppCloudStatusDownloading)
    k_EAppCloudStatusDownloading = 7,
    // @@protoc_insertion_point(enum_value:EAppCloudStatus.k_EAppCloudStatusSyncFailed)
    k_EAppCloudStatusSyncFailed = 8,
    // @@protoc_insertion_point(enum_value:EAppCloudStatus.k_EAppCloudStatusConflict)
    k_EAppCloudStatusConflict = 9,
    // @@protoc_insertion_point(enum_value:EAppCloudStatus.k_EAppCloudStatusPendingElsewhere)
    k_EAppCloudStatusPendingElsewhere = 10,
}

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

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

    fn from_i32(value: i32) -> ::std::option::Option<EAppCloudStatus> {
        match value {
            0 => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusInvalid),
            1 => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusDisabled),
            2 => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusUnknown),
            3 => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusSynchronized),
            4 => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusChecking),
            5 => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusOutOfSync),
            6 => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusUploading),
            7 => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusDownloading),
            8 => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusSyncFailed),
            9 => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusConflict),
            10 => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusPendingElsewhere),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<EAppCloudStatus> {
        match str {
            "k_EAppCloudStatusInvalid" => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusInvalid),
            "k_EAppCloudStatusDisabled" => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusDisabled),
            "k_EAppCloudStatusUnknown" => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusUnknown),
            "k_EAppCloudStatusSynchronized" => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusSynchronized),
            "k_EAppCloudStatusChecking" => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusChecking),
            "k_EAppCloudStatusOutOfSync" => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusOutOfSync),
            "k_EAppCloudStatusUploading" => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusUploading),
            "k_EAppCloudStatusDownloading" => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusDownloading),
            "k_EAppCloudStatusSyncFailed" => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusSyncFailed),
            "k_EAppCloudStatusConflict" => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusConflict),
            "k_EAppCloudStatusPendingElsewhere" => ::std::option::Option::Some(EAppCloudStatus::k_EAppCloudStatusPendingElsewhere),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [EAppCloudStatus] = &[
        EAppCloudStatus::k_EAppCloudStatusInvalid,
        EAppCloudStatus::k_EAppCloudStatusDisabled,
        EAppCloudStatus::k_EAppCloudStatusUnknown,
        EAppCloudStatus::k_EAppCloudStatusSynchronized,
        EAppCloudStatus::k_EAppCloudStatusChecking,
        EAppCloudStatus::k_EAppCloudStatusOutOfSync,
        EAppCloudStatus::k_EAppCloudStatusUploading,
        EAppCloudStatus::k_EAppCloudStatusDownloading,
        EAppCloudStatus::k_EAppCloudStatusSyncFailed,
        EAppCloudStatus::k_EAppCloudStatusConflict,
        EAppCloudStatus::k_EAppCloudStatusPendingElsewhere,
    ];
}

impl ::std::default::Default for EAppCloudStatus {
    fn default() -> Self {
        EAppCloudStatus::k_EAppCloudStatusInvalid
    }
}


#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:EProtoAppType)
pub enum EProtoAppType {
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeInvalid)
    k_EAppTypeInvalid = 0,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeGame)
    k_EAppTypeGame = 1,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeApplication)
    k_EAppTypeApplication = 2,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeTool)
    k_EAppTypeTool = 4,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeDemo)
    k_EAppTypeDemo = 8,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeDeprected)
    k_EAppTypeDeprected = 16,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeDLC)
    k_EAppTypeDLC = 32,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeGuide)
    k_EAppTypeGuide = 64,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeDriver)
    k_EAppTypeDriver = 128,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeConfig)
    k_EAppTypeConfig = 256,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeHardware)
    k_EAppTypeHardware = 512,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeFranchise)
    k_EAppTypeFranchise = 1024,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeVideo)
    k_EAppTypeVideo = 2048,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypePlugin)
    k_EAppTypePlugin = 4096,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeMusicAlbum)
    k_EAppTypeMusicAlbum = 8192,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeSeries)
    k_EAppTypeSeries = 16384,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeComic)
    k_EAppTypeComic = 32768,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeBeta)
    k_EAppTypeBeta = 65536,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeShortcut)
    k_EAppTypeShortcut = 1073741824,
    // @@protoc_insertion_point(enum_value:EProtoAppType.k_EAppTypeDepotOnly)
    k_EAppTypeDepotOnly = -2147483648,
}

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

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

    fn from_i32(value: i32) -> ::std::option::Option<EProtoAppType> {
        match value {
            0 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeInvalid),
            1 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeGame),
            2 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeApplication),
            4 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeTool),
            8 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeDemo),
            16 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeDeprected),
            32 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeDLC),
            64 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeGuide),
            128 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeDriver),
            256 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeConfig),
            512 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeHardware),
            1024 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeFranchise),
            2048 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeVideo),
            4096 => ::std::option::Option::Some(EProtoAppType::k_EAppTypePlugin),
            8192 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeMusicAlbum),
            16384 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeSeries),
            32768 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeComic),
            65536 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeBeta),
            1073741824 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeShortcut),
            -2147483648 => ::std::option::Option::Some(EProtoAppType::k_EAppTypeDepotOnly),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<EProtoAppType> {
        match str {
            "k_EAppTypeInvalid" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeInvalid),
            "k_EAppTypeGame" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeGame),
            "k_EAppTypeApplication" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeApplication),
            "k_EAppTypeTool" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeTool),
            "k_EAppTypeDemo" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeDemo),
            "k_EAppTypeDeprected" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeDeprected),
            "k_EAppTypeDLC" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeDLC),
            "k_EAppTypeGuide" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeGuide),
            "k_EAppTypeDriver" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeDriver),
            "k_EAppTypeConfig" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeConfig),
            "k_EAppTypeHardware" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeHardware),
            "k_EAppTypeFranchise" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeFranchise),
            "k_EAppTypeVideo" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeVideo),
            "k_EAppTypePlugin" => ::std::option::Option::Some(EProtoAppType::k_EAppTypePlugin),
            "k_EAppTypeMusicAlbum" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeMusicAlbum),
            "k_EAppTypeSeries" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeSeries),
            "k_EAppTypeComic" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeComic),
            "k_EAppTypeBeta" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeBeta),
            "k_EAppTypeShortcut" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeShortcut),
            "k_EAppTypeDepotOnly" => ::std::option::Option::Some(EProtoAppType::k_EAppTypeDepotOnly),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [EProtoAppType] = &[
        EProtoAppType::k_EAppTypeInvalid,
        EProtoAppType::k_EAppTypeGame,
        EProtoAppType::k_EAppTypeApplication,
        EProtoAppType::k_EAppTypeTool,
        EProtoAppType::k_EAppTypeDemo,
        EProtoAppType::k_EAppTypeDeprected,
        EProtoAppType::k_EAppTypeDLC,
        EProtoAppType::k_EAppTypeGuide,
        EProtoAppType::k_EAppTypeDriver,
        EProtoAppType::k_EAppTypeConfig,
        EProtoAppType::k_EAppTypeHardware,
        EProtoAppType::k_EAppTypeFranchise,
        EProtoAppType::k_EAppTypeVideo,
        EProtoAppType::k_EAppTypePlugin,
        EProtoAppType::k_EAppTypeMusicAlbum,
        EProtoAppType::k_EAppTypeSeries,
        EProtoAppType::k_EAppTypeComic,
        EProtoAppType::k_EAppTypeBeta,
        EProtoAppType::k_EAppTypeShortcut,
        EProtoAppType::k_EAppTypeDepotOnly,
    ];
}

impl ::std::default::Default for EProtoAppType {
    fn default() -> Self {
        EProtoAppType::k_EAppTypeInvalid
    }
}


#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:EAppAssociationType)
pub enum EAppAssociationType {
    // @@protoc_insertion_point(enum_value:EAppAssociationType.k_EAppAssociationTypeInvalid)
    k_EAppAssociationTypeInvalid = 0,
    // @@protoc_insertion_point(enum_value:EAppAssociationType.k_EAppAssociationTypePublisher)
    k_EAppAssociationTypePublisher = 1,
    // @@protoc_insertion_point(enum_value:EAppAssociationType.k_EAppAssociationTypeDeveloper)
    k_EAppAssociationTypeDeveloper = 2,
    // @@protoc_insertion_point(enum_value:EAppAssociationType.k_EAppAssociationTypeFranchise)
    k_EAppAssociationTypeFranchise = 3,
}

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

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

    fn from_i32(value: i32) -> ::std::option::Option<EAppAssociationType> {
        match value {
            0 => ::std::option::Option::Some(EAppAssociationType::k_EAppAssociationTypeInvalid),
            1 => ::std::option::Option::Some(EAppAssociationType::k_EAppAssociationTypePublisher),
            2 => ::std::option::Option::Some(EAppAssociationType::k_EAppAssociationTypeDeveloper),
            3 => ::std::option::Option::Some(EAppAssociationType::k_EAppAssociationTypeFranchise),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<EAppAssociationType> {
        match str {
            "k_EAppAssociationTypeInvalid" => ::std::option::Option::Some(EAppAssociationType::k_EAppAssociationTypeInvalid),
            "k_EAppAssociationTypePublisher" => ::std::option::Option::Some(EAppAssociationType::k_EAppAssociationTypePublisher),
            "k_EAppAssociationTypeDeveloper" => ::std::option::Option::Some(EAppAssociationType::k_EAppAssociationTypeDeveloper),
            "k_EAppAssociationTypeFranchise" => ::std::option::Option::Some(EAppAssociationType::k_EAppAssociationTypeFranchise),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [EAppAssociationType] = &[
        EAppAssociationType::k_EAppAssociationTypeInvalid,
        EAppAssociationType::k_EAppAssociationTypePublisher,
        EAppAssociationType::k_EAppAssociationTypeDeveloper,
        EAppAssociationType::k_EAppAssociationTypeFranchise,
    ];
}

impl ::std::default::Default for EAppAssociationType {
    fn default() -> Self {
        EAppAssociationType::k_EAppAssociationTypeInvalid
    }
}


#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:EAppControllerSupportLevel)
pub enum EAppControllerSupportLevel {
    // @@protoc_insertion_point(enum_value:EAppControllerSupportLevel.k_EAppControllerSupportLevelNone)
    k_EAppControllerSupportLevelNone = 0,
    // @@protoc_insertion_point(enum_value:EAppControllerSupportLevel.k_EAppControllerSupportLevelPartial)
    k_EAppControllerSupportLevelPartial = 1,
    // @@protoc_insertion_point(enum_value:EAppControllerSupportLevel.k_EAppControllerSupportLevelFull)
    k_EAppControllerSupportLevelFull = 2,
}

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

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

    fn from_i32(value: i32) -> ::std::option::Option<EAppControllerSupportLevel> {
        match value {
            0 => ::std::option::Option::Some(EAppControllerSupportLevel::k_EAppControllerSupportLevelNone),
            1 => ::std::option::Option::Some(EAppControllerSupportLevel::k_EAppControllerSupportLevelPartial),
            2 => ::std::option::Option::Some(EAppControllerSupportLevel::k_EAppControllerSupportLevelFull),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<EAppControllerSupportLevel> {
        match str {
            "k_EAppControllerSupportLevelNone" => ::std::option::Option::Some(EAppControllerSupportLevel::k_EAppControllerSupportLevelNone),
            "k_EAppControllerSupportLevelPartial" => ::std::option::Option::Some(EAppControllerSupportLevel::k_EAppControllerSupportLevelPartial),
            "k_EAppControllerSupportLevelFull" => ::std::option::Option::Some(EAppControllerSupportLevel::k_EAppControllerSupportLevelFull),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [EAppControllerSupportLevel] = &[
        EAppControllerSupportLevel::k_EAppControllerSupportLevelNone,
        EAppControllerSupportLevel::k_EAppControllerSupportLevelPartial,
        EAppControllerSupportLevel::k_EAppControllerSupportLevelFull,
    ];
}

impl ::std::default::Default for EAppControllerSupportLevel {
    fn default() -> Self {
        EAppControllerSupportLevel::k_EAppControllerSupportLevelNone
    }
}


#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:EAppGamepadGyroTrackpadSupportLevel)
pub enum EAppGamepadGyroTrackpadSupportLevel {
    // @@protoc_insertion_point(enum_value:EAppGamepadGyroTrackpadSupportLevel.k_EAppGamepadGyroTrackpadSupportLevelUnknown)
    k_EAppGamepadGyroTrackpadSupportLevelUnknown = -1,
    // @@protoc_insertion_point(enum_value:EAppGamepadGyroTrackpadSupportLevel.k_EAppGamepadGyroTrackpadSupportLevelNoGamepad)
    k_EAppGamepadGyroTrackpadSupportLevelNoGamepad = 0,
    // @@protoc_insertion_point(enum_value:EAppGamepadGyroTrackpadSupportLevel.k_EAppGamepadGyroTrackpadSupportLevelGamepad)
    k_EAppGamepadGyroTrackpadSupportLevelGamepad = 1,
    // @@protoc_insertion_point(enum_value:EAppGamepadGyroTrackpadSupportLevel.k_EAppGamepadGyroTrackpadSupportLevelSimultaneous)
    k_EAppGamepadGyroTrackpadSupportLevelSimultaneous = 2,
}

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

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

    fn from_i32(value: i32) -> ::std::option::Option<EAppGamepadGyroTrackpadSupportLevel> {
        match value {
            -1 => ::std::option::Option::Some(EAppGamepadGyroTrackpadSupportLevel::k_EAppGamepadGyroTrackpadSupportLevelUnknown),
            0 => ::std::option::Option::Some(EAppGamepadGyroTrackpadSupportLevel::k_EAppGamepadGyroTrackpadSupportLevelNoGamepad),
            1 => ::std::option::Option::Some(EAppGamepadGyroTrackpadSupportLevel::k_EAppGamepadGyroTrackpadSupportLevelGamepad),
            2 => ::std::option::Option::Some(EAppGamepadGyroTrackpadSupportLevel::k_EAppGamepadGyroTrackpadSupportLevelSimultaneous),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<EAppGamepadGyroTrackpadSupportLevel> {
        match str {
            "k_EAppGamepadGyroTrackpadSupportLevelUnknown" => ::std::option::Option::Some(EAppGamepadGyroTrackpadSupportLevel::k_EAppGamepadGyroTrackpadSupportLevelUnknown),
            "k_EAppGamepadGyroTrackpadSupportLevelNoGamepad" => ::std::option::Option::Some(EAppGamepadGyroTrackpadSupportLevel::k_EAppGamepadGyroTrackpadSupportLevelNoGamepad),
            "k_EAppGamepadGyroTrackpadSupportLevelGamepad" => ::std::option::Option::Some(EAppGamepadGyroTrackpadSupportLevel::k_EAppGamepadGyroTrackpadSupportLevelGamepad),
            "k_EAppGamepadGyroTrackpadSupportLevelSimultaneous" => ::std::option::Option::Some(EAppGamepadGyroTrackpadSupportLevel::k_EAppGamepadGyroTrackpadSupportLevelSimultaneous),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [EAppGamepadGyroTrackpadSupportLevel] = &[
        EAppGamepadGyroTrackpadSupportLevel::k_EAppGamepadGyroTrackpadSupportLevelUnknown,
        EAppGamepadGyroTrackpadSupportLevel::k_EAppGamepadGyroTrackpadSupportLevelNoGamepad,
        EAppGamepadGyroTrackpadSupportLevel::k_EAppGamepadGyroTrackpadSupportLevelGamepad,
        EAppGamepadGyroTrackpadSupportLevel::k_EAppGamepadGyroTrackpadSupportLevelSimultaneous,
    ];
}

// Note, `Default` is implemented although default value is not 0
impl ::std::default::Default for EAppGamepadGyroTrackpadSupportLevel {
    fn default() -> Self {
        EAppGamepadGyroTrackpadSupportLevel::k_EAppGamepadGyroTrackpadSupportLevelUnknown
    }
}

#[allow(unused_imports)]
use crate::enums::*;
impl crate::RpcMessage for CAppOverview_AppAssociation {
    fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
        <Self as protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
        use protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use protobuf::Message;
        self.compute_size() as usize
    }
}
impl crate::RpcMessage for CAppOverview_PerClientData {
    fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
        <Self as protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
        use protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use protobuf::Message;
        self.compute_size() as usize
    }
}
impl crate::RpcMessage for CAppOverview {
    fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
        <Self as protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
        use protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use protobuf::Message;
        self.compute_size() as usize
    }
}
impl crate::RpcMessage for CAppOverview_Change {
    fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
        <Self as protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
        use protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use protobuf::Message;
        self.compute_size() as usize
    }
}
impl crate::RpcMessage for CAppBootstrapData {
    fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
        <Self as protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
        use protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use protobuf::Message;
        self.compute_size() as usize
    }
}
impl crate::RpcMessage for CLibraryBootstrapData {
    fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
        <Self as protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
        use protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use protobuf::Message;
        self.compute_size() as usize
    }
}