steam-vent-proto 0.1.0

// This file is generated by rust-protobuf 2.24.1. Do not edit
// @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_imports)]
#![allow(unused_results)]
//! Generated file from `steammessages_store.steamclient.proto`

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

#[derive(PartialEq,Clone,Default)]
pub struct CStore_GetMostPopularTags_Request {
    // message fields
    language: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string language = 1;


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

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

    // Param is passed by value, moved
    pub fn set_language(&mut self, v: ::std::string::String) {
        self.language = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_language(&mut self) -> &mut ::std::string::String {
        if self.language.is_none() {
            self.language.set_default();
        }
        self.language.as_mut().unwrap()
    }

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

impl ::protobuf::Message for CStore_GetMostPopularTags_Request {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.language)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.language.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

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

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "language",
                |m: &CStore_GetMostPopularTags_Request| { &m.language },
                |m: &mut CStore_GetMostPopularTags_Request| { &mut m.language },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CStore_GetMostPopularTags_Request>(
                "CStore_GetMostPopularTags_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CStore_GetMostPopularTags_Request {
        static instance: ::protobuf::rt::LazyV2<CStore_GetMostPopularTags_Request> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CStore_GetMostPopularTags_Request::new)
    }
}

impl ::protobuf::Clear for CStore_GetMostPopularTags_Request {
    fn clear(&mut self) {
        self.language.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CStore_GetMostPopularTags_Request {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CStore_GetMostPopularTags_Request {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CStore_GetMostPopularTags_Response {
    // message fields
    pub tags: ::protobuf::RepeatedField<CStore_GetMostPopularTags_Response_Tag>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .CStore_GetMostPopularTags_Response.Tag tags = 1;


    pub fn get_tags(&self) -> &[CStore_GetMostPopularTags_Response_Tag] {
        &self.tags
    }
    pub fn clear_tags(&mut self) {
        self.tags.clear();
    }

    // Param is passed by value, moved
    pub fn set_tags(&mut self, v: ::protobuf::RepeatedField<CStore_GetMostPopularTags_Response_Tag>) {
        self.tags = v;
    }

    // Mutable pointer to the field.
    pub fn mut_tags(&mut self) -> &mut ::protobuf::RepeatedField<CStore_GetMostPopularTags_Response_Tag> {
        &mut self.tags
    }

    // Take field
    pub fn take_tags(&mut self) -> ::protobuf::RepeatedField<CStore_GetMostPopularTags_Response_Tag> {
        ::std::mem::replace(&mut self.tags, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for CStore_GetMostPopularTags_Response {
    fn is_initialized(&self) -> bool {
        for v in &self.tags {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.tags)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.tags {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CStore_GetMostPopularTags_Response_Tag>>(
                "tags",
                |m: &CStore_GetMostPopularTags_Response| { &m.tags },
                |m: &mut CStore_GetMostPopularTags_Response| { &mut m.tags },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CStore_GetMostPopularTags_Response>(
                "CStore_GetMostPopularTags_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CStore_GetMostPopularTags_Response {
        static instance: ::protobuf::rt::LazyV2<CStore_GetMostPopularTags_Response> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CStore_GetMostPopularTags_Response::new)
    }
}

impl ::protobuf::Clear for CStore_GetMostPopularTags_Response {
    fn clear(&mut self) {
        self.tags.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CStore_GetMostPopularTags_Response {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CStore_GetMostPopularTags_Response {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CStore_GetMostPopularTags_Response_Tag {
    // message fields
    tagid: ::std::option::Option<u32>,
    name: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 tagid = 1;


    pub fn get_tagid(&self) -> u32 {
        self.tagid.unwrap_or(0)
    }
    pub fn clear_tagid(&mut self) {
        self.tagid = ::std::option::Option::None;
    }

    pub fn has_tagid(&self) -> bool {
        self.tagid.is_some()
    }

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

    // optional string name = 2;


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

    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 = ::protobuf::SingularField::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.set_default();
        }
        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 CStore_GetMostPopularTags_Response_Tag {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.tagid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.tagid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.tagid {
            os.write_uint32(1, v)?;
        }
        if let Some(ref v) = self.name.as_ref() {
            os.write_string(2, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "tagid",
                |m: &CStore_GetMostPopularTags_Response_Tag| { &m.tagid },
                |m: &mut CStore_GetMostPopularTags_Response_Tag| { &mut m.tagid },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &CStore_GetMostPopularTags_Response_Tag| { &m.name },
                |m: &mut CStore_GetMostPopularTags_Response_Tag| { &mut m.name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CStore_GetMostPopularTags_Response_Tag>(
                "CStore_GetMostPopularTags_Response.Tag",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CStore_GetMostPopularTags_Response_Tag {
        static instance: ::protobuf::rt::LazyV2<CStore_GetMostPopularTags_Response_Tag> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CStore_GetMostPopularTags_Response_Tag::new)
    }
}

impl ::protobuf::Clear for CStore_GetMostPopularTags_Response_Tag {
    fn clear(&mut self) {
        self.tagid = ::std::option::Option::None;
        self.name.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CStore_GetMostPopularTags_Response_Tag {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CStore_GetMostPopularTags_Response_Tag {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CStore_GetLocalizedNameForTags_Request {
    // message fields
    language: ::protobuf::SingularField<::std::string::String>,
    pub tagids: ::std::vec::Vec<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string language = 1;


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

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

    // Param is passed by value, moved
    pub fn set_language(&mut self, v: ::std::string::String) {
        self.language = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_language(&mut self) -> &mut ::std::string::String {
        if self.language.is_none() {
            self.language.set_default();
        }
        self.language.as_mut().unwrap()
    }

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

    // repeated uint32 tagids = 2;


    pub fn get_tagids(&self) -> &[u32] {
        &self.tagids
    }
    pub fn clear_tagids(&mut self) {
        self.tagids.clear();
    }

    // Param is passed by value, moved
    pub fn set_tagids(&mut self, v: ::std::vec::Vec<u32>) {
        self.tagids = v;
    }

    // Mutable pointer to the field.
    pub fn mut_tagids(&mut self) -> &mut ::std::vec::Vec<u32> {
        &mut self.tagids
    }

    // Take field
    pub fn take_tagids(&mut self) -> ::std::vec::Vec<u32> {
        ::std::mem::replace(&mut self.tagids, ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for CStore_GetLocalizedNameForTags_Request {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.language)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_uint32_into(wire_type, is, &mut self.tagids)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.language.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        for value in &self.tagids {
            my_size += ::protobuf::rt::value_size(2, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.language.as_ref() {
            os.write_string(1, &v)?;
        }
        for v in &self.tagids {
            os.write_uint32(2, *v)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "language",
                |m: &CStore_GetLocalizedNameForTags_Request| { &m.language },
                |m: &mut CStore_GetLocalizedNameForTags_Request| { &mut m.language },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "tagids",
                |m: &CStore_GetLocalizedNameForTags_Request| { &m.tagids },
                |m: &mut CStore_GetLocalizedNameForTags_Request| { &mut m.tagids },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CStore_GetLocalizedNameForTags_Request>(
                "CStore_GetLocalizedNameForTags_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CStore_GetLocalizedNameForTags_Request {
        static instance: ::protobuf::rt::LazyV2<CStore_GetLocalizedNameForTags_Request> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CStore_GetLocalizedNameForTags_Request::new)
    }
}

impl ::protobuf::Clear for CStore_GetLocalizedNameForTags_Request {
    fn clear(&mut self) {
        self.language.clear();
        self.tagids.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CStore_GetLocalizedNameForTags_Request {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CStore_GetLocalizedNameForTags_Request {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CStore_GetLocalizedNameForTags_Response {
    // message fields
    pub tags: ::protobuf::RepeatedField<CStore_GetLocalizedNameForTags_Response_Tag>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .CStore_GetLocalizedNameForTags_Response.Tag tags = 1;


    pub fn get_tags(&self) -> &[CStore_GetLocalizedNameForTags_Response_Tag] {
        &self.tags
    }
    pub fn clear_tags(&mut self) {
        self.tags.clear();
    }

    // Param is passed by value, moved
    pub fn set_tags(&mut self, v: ::protobuf::RepeatedField<CStore_GetLocalizedNameForTags_Response_Tag>) {
        self.tags = v;
    }

    // Mutable pointer to the field.
    pub fn mut_tags(&mut self) -> &mut ::protobuf::RepeatedField<CStore_GetLocalizedNameForTags_Response_Tag> {
        &mut self.tags
    }

    // Take field
    pub fn take_tags(&mut self) -> ::protobuf::RepeatedField<CStore_GetLocalizedNameForTags_Response_Tag> {
        ::std::mem::replace(&mut self.tags, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for CStore_GetLocalizedNameForTags_Response {
    fn is_initialized(&self) -> bool {
        for v in &self.tags {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.tags)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.tags {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CStore_GetLocalizedNameForTags_Response_Tag>>(
                "tags",
                |m: &CStore_GetLocalizedNameForTags_Response| { &m.tags },
                |m: &mut CStore_GetLocalizedNameForTags_Response| { &mut m.tags },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CStore_GetLocalizedNameForTags_Response>(
                "CStore_GetLocalizedNameForTags_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CStore_GetLocalizedNameForTags_Response {
        static instance: ::protobuf::rt::LazyV2<CStore_GetLocalizedNameForTags_Response> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CStore_GetLocalizedNameForTags_Response::new)
    }
}

impl ::protobuf::Clear for CStore_GetLocalizedNameForTags_Response {
    fn clear(&mut self) {
        self.tags.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CStore_GetLocalizedNameForTags_Response {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CStore_GetLocalizedNameForTags_Response {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CStore_GetLocalizedNameForTags_Response_Tag {
    // message fields
    tagid: ::std::option::Option<u32>,
    english_name: ::protobuf::SingularField<::std::string::String>,
    name: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 tagid = 1;


    pub fn get_tagid(&self) -> u32 {
        self.tagid.unwrap_or(0)
    }
    pub fn clear_tagid(&mut self) {
        self.tagid = ::std::option::Option::None;
    }

    pub fn has_tagid(&self) -> bool {
        self.tagid.is_some()
    }

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

    // optional string english_name = 2;


    pub fn get_english_name(&self) -> &str {
        match self.english_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_english_name(&mut self) {
        self.english_name.clear();
    }

    pub fn has_english_name(&self) -> bool {
        self.english_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_english_name(&mut self, v: ::std::string::String) {
        self.english_name = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_english_name(&mut self) -> &mut ::std::string::String {
        if self.english_name.is_none() {
            self.english_name.set_default();
        }
        self.english_name.as_mut().unwrap()
    }

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

    // optional string name = 3;


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

    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 = ::protobuf::SingularField::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.set_default();
        }
        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 CStore_GetLocalizedNameForTags_Response_Tag {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.tagid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.english_name)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.tagid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.english_name.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(ref v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.tagid {
            os.write_uint32(1, v)?;
        }
        if let Some(ref v) = self.english_name.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(ref v) = self.name.as_ref() {
            os.write_string(3, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "tagid",
                |m: &CStore_GetLocalizedNameForTags_Response_Tag| { &m.tagid },
                |m: &mut CStore_GetLocalizedNameForTags_Response_Tag| { &mut m.tagid },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "english_name",
                |m: &CStore_GetLocalizedNameForTags_Response_Tag| { &m.english_name },
                |m: &mut CStore_GetLocalizedNameForTags_Response_Tag| { &mut m.english_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &CStore_GetLocalizedNameForTags_Response_Tag| { &m.name },
                |m: &mut CStore_GetLocalizedNameForTags_Response_Tag| { &mut m.name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CStore_GetLocalizedNameForTags_Response_Tag>(
                "CStore_GetLocalizedNameForTags_Response.Tag",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CStore_GetLocalizedNameForTags_Response_Tag {
        static instance: ::protobuf::rt::LazyV2<CStore_GetLocalizedNameForTags_Response_Tag> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CStore_GetLocalizedNameForTags_Response_Tag::new)
    }
}

impl ::protobuf::Clear for CStore_GetLocalizedNameForTags_Response_Tag {
    fn clear(&mut self) {
        self.tagid = ::std::option::Option::None;
        self.english_name.clear();
        self.name.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CStore_GetLocalizedNameForTags_Response_Tag {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CStore_GetLocalizedNameForTags_Response_Tag {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CStore_GetStorePreferences_Request {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

impl ::protobuf::Message for CStore_GetStorePreferences_Request {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let fields = ::std::vec::Vec::new();
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CStore_GetStorePreferences_Request>(
                "CStore_GetStorePreferences_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CStore_GetStorePreferences_Request {
        static instance: ::protobuf::rt::LazyV2<CStore_GetStorePreferences_Request> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CStore_GetStorePreferences_Request::new)
    }
}

impl ::protobuf::Clear for CStore_GetStorePreferences_Request {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CStore_GetStorePreferences_Request {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CStore_GetStorePreferences_Request {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CStore_UserPreferences {
    // message fields
    primary_language: ::std::option::Option<u32>,
    secondary_languages: ::std::option::Option<u32>,
    platform_windows: ::std::option::Option<bool>,
    platform_mac: ::std::option::Option<bool>,
    platform_linux: ::std::option::Option<bool>,
    hide_adult_content_violence: ::std::option::Option<bool>,
    hide_adult_content_sex: ::std::option::Option<bool>,
    timestamp_updated: ::std::option::Option<u32>,
    hide_store_broadcast: ::std::option::Option<bool>,
    review_score_preference: ::std::option::Option<EUserReviewScorePreference>,
    timestamp_content_descriptor_preferences_updated: ::std::option::Option<i32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 primary_language = 1;


    pub fn get_primary_language(&self) -> u32 {
        self.primary_language.unwrap_or(0)
    }
    pub fn clear_primary_language(&mut self) {
        self.primary_language = ::std::option::Option::None;
    }

    pub fn has_primary_language(&self) -> bool {
        self.primary_language.is_some()
    }

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

    // optional uint32 secondary_languages = 2;


    pub fn get_secondary_languages(&self) -> u32 {
        self.secondary_languages.unwrap_or(0)
    }
    pub fn clear_secondary_languages(&mut self) {
        self.secondary_languages = ::std::option::Option::None;
    }

    pub fn has_secondary_languages(&self) -> bool {
        self.secondary_languages.is_some()
    }

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

    // optional bool platform_windows = 3;


    pub fn get_platform_windows(&self) -> bool {
        self.platform_windows.unwrap_or(false)
    }
    pub fn clear_platform_windows(&mut self) {
        self.platform_windows = ::std::option::Option::None;
    }

    pub fn has_platform_windows(&self) -> bool {
        self.platform_windows.is_some()
    }

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

    // optional bool platform_mac = 4;


    pub fn get_platform_mac(&self) -> bool {
        self.platform_mac.unwrap_or(false)
    }
    pub fn clear_platform_mac(&mut self) {
        self.platform_mac = ::std::option::Option::None;
    }

    pub fn has_platform_mac(&self) -> bool {
        self.platform_mac.is_some()
    }

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

    // optional bool platform_linux = 5;


    pub fn get_platform_linux(&self) -> bool {
        self.platform_linux.unwrap_or(false)
    }
    pub fn clear_platform_linux(&mut self) {
        self.platform_linux = ::std::option::Option::None;
    }

    pub fn has_platform_linux(&self) -> bool {
        self.platform_linux.is_some()
    }

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

    // optional bool hide_adult_content_violence = 6;


    pub fn get_hide_adult_content_violence(&self) -> bool {
        self.hide_adult_content_violence.unwrap_or(false)
    }
    pub fn clear_hide_adult_content_violence(&mut self) {
        self.hide_adult_content_violence = ::std::option::Option::None;
    }

    pub fn has_hide_adult_content_violence(&self) -> bool {
        self.hide_adult_content_violence.is_some()
    }

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

    // optional bool hide_adult_content_sex = 7;


    pub fn get_hide_adult_content_sex(&self) -> bool {
        self.hide_adult_content_sex.unwrap_or(false)
    }
    pub fn clear_hide_adult_content_sex(&mut self) {
        self.hide_adult_content_sex = ::std::option::Option::None;
    }

    pub fn has_hide_adult_content_sex(&self) -> bool {
        self.hide_adult_content_sex.is_some()
    }

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

    // optional uint32 timestamp_updated = 8;


    pub fn get_timestamp_updated(&self) -> u32 {
        self.timestamp_updated.unwrap_or(0)
    }
    pub fn clear_timestamp_updated(&mut self) {
        self.timestamp_updated = ::std::option::Option::None;
    }

    pub fn has_timestamp_updated(&self) -> bool {
        self.timestamp_updated.is_some()
    }

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

    // optional bool hide_store_broadcast = 9;


    pub fn get_hide_store_broadcast(&self) -> bool {
        self.hide_store_broadcast.unwrap_or(false)
    }
    pub fn clear_hide_store_broadcast(&mut self) {
        self.hide_store_broadcast = ::std::option::Option::None;
    }

    pub fn has_hide_store_broadcast(&self) -> bool {
        self.hide_store_broadcast.is_some()
    }

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

    // optional .EUserReviewScorePreference review_score_preference = 10;


    pub fn get_review_score_preference(&self) -> EUserReviewScorePreference {
        self.review_score_preference.unwrap_or(EUserReviewScorePreference::k_EUserReviewScorePreference_Unset)
    }
    pub fn clear_review_score_preference(&mut self) {
        self.review_score_preference = ::std::option::Option::None;
    }

    pub fn has_review_score_preference(&self) -> bool {
        self.review_score_preference.is_some()
    }

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

    // optional int32 timestamp_content_descriptor_preferences_updated = 11;


    pub fn get_timestamp_content_descriptor_preferences_updated(&self) -> i32 {
        self.timestamp_content_descriptor_preferences_updated.unwrap_or(0)
    }
    pub fn clear_timestamp_content_descriptor_preferences_updated(&mut self) {
        self.timestamp_content_descriptor_preferences_updated = ::std::option::Option::None;
    }

    pub fn has_timestamp_content_descriptor_preferences_updated(&self) -> bool {
        self.timestamp_content_descriptor_preferences_updated.is_some()
    }

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

impl ::protobuf::Message for CStore_UserPreferences {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.primary_language = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.secondary_languages = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.platform_windows = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.platform_mac = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.platform_linux = ::std::option::Option::Some(tmp);
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.hide_adult_content_violence = ::std::option::Option::Some(tmp);
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.hide_adult_content_sex = ::std::option::Option::Some(tmp);
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.timestamp_updated = ::std::option::Option::Some(tmp);
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.hide_store_broadcast = ::std::option::Option::Some(tmp);
                },
                10 => {
                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.review_score_preference, 10, &mut self.unknown_fields)?
                },
                11 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.timestamp_content_descriptor_preferences_updated = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.primary_language {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.secondary_languages {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.platform_windows {
            my_size += 2;
        }
        if let Some(v) = self.platform_mac {
            my_size += 2;
        }
        if let Some(v) = self.platform_linux {
            my_size += 2;
        }
        if let Some(v) = self.hide_adult_content_violence {
            my_size += 2;
        }
        if let Some(v) = self.hide_adult_content_sex {
            my_size += 2;
        }
        if let Some(v) = self.timestamp_updated {
            my_size += ::protobuf::rt::value_size(8, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.hide_store_broadcast {
            my_size += 2;
        }
        if let Some(v) = self.review_score_preference {
            my_size += ::protobuf::rt::enum_size(10, v);
        }
        if let Some(v) = self.timestamp_content_descriptor_preferences_updated {
            my_size += ::protobuf::rt::value_size(11, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.primary_language {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.secondary_languages {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.platform_windows {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.platform_mac {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.platform_linux {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.hide_adult_content_violence {
            os.write_bool(6, v)?;
        }
        if let Some(v) = self.hide_adult_content_sex {
            os.write_bool(7, v)?;
        }
        if let Some(v) = self.timestamp_updated {
            os.write_uint32(8, v)?;
        }
        if let Some(v) = self.hide_store_broadcast {
            os.write_bool(9, v)?;
        }
        if let Some(v) = self.review_score_preference {
            os.write_enum(10, ::protobuf::ProtobufEnum::value(&v))?;
        }
        if let Some(v) = self.timestamp_content_descriptor_preferences_updated {
            os.write_int32(11, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "primary_language",
                |m: &CStore_UserPreferences| { &m.primary_language },
                |m: &mut CStore_UserPreferences| { &mut m.primary_language },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "secondary_languages",
                |m: &CStore_UserPreferences| { &m.secondary_languages },
                |m: &mut CStore_UserPreferences| { &mut m.secondary_languages },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "platform_windows",
                |m: &CStore_UserPreferences| { &m.platform_windows },
                |m: &mut CStore_UserPreferences| { &mut m.platform_windows },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "platform_mac",
                |m: &CStore_UserPreferences| { &m.platform_mac },
                |m: &mut CStore_UserPreferences| { &mut m.platform_mac },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "platform_linux",
                |m: &CStore_UserPreferences| { &m.platform_linux },
                |m: &mut CStore_UserPreferences| { &mut m.platform_linux },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "hide_adult_content_violence",
                |m: &CStore_UserPreferences| { &m.hide_adult_content_violence },
                |m: &mut CStore_UserPreferences| { &mut m.hide_adult_content_violence },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "hide_adult_content_sex",
                |m: &CStore_UserPreferences| { &m.hide_adult_content_sex },
                |m: &mut CStore_UserPreferences| { &mut m.hide_adult_content_sex },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "timestamp_updated",
                |m: &CStore_UserPreferences| { &m.timestamp_updated },
                |m: &mut CStore_UserPreferences| { &mut m.timestamp_updated },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "hide_store_broadcast",
                |m: &CStore_UserPreferences| { &m.hide_store_broadcast },
                |m: &mut CStore_UserPreferences| { &mut m.hide_store_broadcast },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EUserReviewScorePreference>>(
                "review_score_preference",
                |m: &CStore_UserPreferences| { &m.review_score_preference },
                |m: &mut CStore_UserPreferences| { &mut m.review_score_preference },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "timestamp_content_descriptor_preferences_updated",
                |m: &CStore_UserPreferences| { &m.timestamp_content_descriptor_preferences_updated },
                |m: &mut CStore_UserPreferences| { &mut m.timestamp_content_descriptor_preferences_updated },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CStore_UserPreferences>(
                "CStore_UserPreferences",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CStore_UserPreferences {
        static instance: ::protobuf::rt::LazyV2<CStore_UserPreferences> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CStore_UserPreferences::new)
    }
}

impl ::protobuf::Clear for CStore_UserPreferences {
    fn clear(&mut self) {
        self.primary_language = ::std::option::Option::None;
        self.secondary_languages = ::std::option::Option::None;
        self.platform_windows = ::std::option::Option::None;
        self.platform_mac = ::std::option::Option::None;
        self.platform_linux = ::std::option::Option::None;
        self.hide_adult_content_violence = ::std::option::Option::None;
        self.hide_adult_content_sex = ::std::option::Option::None;
        self.timestamp_updated = ::std::option::Option::None;
        self.hide_store_broadcast = ::std::option::Option::None;
        self.review_score_preference = ::std::option::Option::None;
        self.timestamp_content_descriptor_preferences_updated = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CStore_UserPreferences {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CStore_UserPreferences {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CStore_UserTagPreferences {
    // message fields
    pub tags_to_exclude: ::protobuf::RepeatedField<CStore_UserTagPreferences_Tag>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .CStore_UserTagPreferences.Tag tags_to_exclude = 1;


    pub fn get_tags_to_exclude(&self) -> &[CStore_UserTagPreferences_Tag] {
        &self.tags_to_exclude
    }
    pub fn clear_tags_to_exclude(&mut self) {
        self.tags_to_exclude.clear();
    }

    // Param is passed by value, moved
    pub fn set_tags_to_exclude(&mut self, v: ::protobuf::RepeatedField<CStore_UserTagPreferences_Tag>) {
        self.tags_to_exclude = v;
    }

    // Mutable pointer to the field.
    pub fn mut_tags_to_exclude(&mut self) -> &mut ::protobuf::RepeatedField<CStore_UserTagPreferences_Tag> {
        &mut self.tags_to_exclude
    }

    // Take field
    pub fn take_tags_to_exclude(&mut self) -> ::protobuf::RepeatedField<CStore_UserTagPreferences_Tag> {
        ::std::mem::replace(&mut self.tags_to_exclude, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for CStore_UserTagPreferences {
    fn is_initialized(&self) -> bool {
        for v in &self.tags_to_exclude {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.tags_to_exclude)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.tags_to_exclude {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CStore_UserTagPreferences_Tag>>(
                "tags_to_exclude",
                |m: &CStore_UserTagPreferences| { &m.tags_to_exclude },
                |m: &mut CStore_UserTagPreferences| { &mut m.tags_to_exclude },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CStore_UserTagPreferences>(
                "CStore_UserTagPreferences",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CStore_UserTagPreferences {
        static instance: ::protobuf::rt::LazyV2<CStore_UserTagPreferences> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CStore_UserTagPreferences::new)
    }
}

impl ::protobuf::Clear for CStore_UserTagPreferences {
    fn clear(&mut self) {
        self.tags_to_exclude.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CStore_UserTagPreferences {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CStore_UserTagPreferences {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CStore_UserTagPreferences_Tag {
    // message fields
    tagid: ::std::option::Option<u32>,
    name: ::protobuf::SingularField<::std::string::String>,
    timestamp_added: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 tagid = 1;


    pub fn get_tagid(&self) -> u32 {
        self.tagid.unwrap_or(0)
    }
    pub fn clear_tagid(&mut self) {
        self.tagid = ::std::option::Option::None;
    }

    pub fn has_tagid(&self) -> bool {
        self.tagid.is_some()
    }

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

    // optional string name = 2;


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

    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 = ::protobuf::SingularField::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.set_default();
        }
        self.name.as_mut().unwrap()
    }

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

    // optional uint32 timestamp_added = 3;


    pub fn get_timestamp_added(&self) -> u32 {
        self.timestamp_added.unwrap_or(0)
    }
    pub fn clear_timestamp_added(&mut self) {
        self.timestamp_added = ::std::option::Option::None;
    }

    pub fn has_timestamp_added(&self) -> bool {
        self.timestamp_added.is_some()
    }

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

impl ::protobuf::Message for CStore_UserTagPreferences_Tag {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.tagid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.timestamp_added = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.tagid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.timestamp_added {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.tagid {
            os.write_uint32(1, v)?;
        }
        if let Some(ref v) = self.name.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.timestamp_added {
            os.write_uint32(3, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "tagid",
                |m: &CStore_UserTagPreferences_Tag| { &m.tagid },
                |m: &mut CStore_UserTagPreferences_Tag| { &mut m.tagid },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &CStore_UserTagPreferences_Tag| { &m.name },
                |m: &mut CStore_UserTagPreferences_Tag| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "timestamp_added",
                |m: &CStore_UserTagPreferences_Tag| { &m.timestamp_added },
                |m: &mut CStore_UserTagPreferences_Tag| { &mut m.timestamp_added },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CStore_UserTagPreferences_Tag>(
                "CStore_UserTagPreferences.Tag",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CStore_UserTagPreferences_Tag {
        static instance: ::protobuf::rt::LazyV2<CStore_UserTagPreferences_Tag> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CStore_UserTagPreferences_Tag::new)
    }
}

impl ::protobuf::Clear for CStore_UserTagPreferences_Tag {
    fn clear(&mut self) {
        self.tagid = ::std::option::Option::None;
        self.name.clear();
        self.timestamp_added = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CStore_UserTagPreferences_Tag {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CStore_UserTagPreferences_Tag {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CStore_UserContentDescriptorPreferences {
    // message fields
    pub content_descriptors_to_exclude: ::protobuf::RepeatedField<CStore_UserContentDescriptorPreferences_ContentDescriptor>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .CStore_UserContentDescriptorPreferences.ContentDescriptor content_descriptors_to_exclude = 1;


    pub fn get_content_descriptors_to_exclude(&self) -> &[CStore_UserContentDescriptorPreferences_ContentDescriptor] {
        &self.content_descriptors_to_exclude
    }
    pub fn clear_content_descriptors_to_exclude(&mut self) {
        self.content_descriptors_to_exclude.clear();
    }

    // Param is passed by value, moved
    pub fn set_content_descriptors_to_exclude(&mut self, v: ::protobuf::RepeatedField<CStore_UserContentDescriptorPreferences_ContentDescriptor>) {
        self.content_descriptors_to_exclude = v;
    }

    // Mutable pointer to the field.
    pub fn mut_content_descriptors_to_exclude(&mut self) -> &mut ::protobuf::RepeatedField<CStore_UserContentDescriptorPreferences_ContentDescriptor> {
        &mut self.content_descriptors_to_exclude
    }

    // Take field
    pub fn take_content_descriptors_to_exclude(&mut self) -> ::protobuf::RepeatedField<CStore_UserContentDescriptorPreferences_ContentDescriptor> {
        ::std::mem::replace(&mut self.content_descriptors_to_exclude, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for CStore_UserContentDescriptorPreferences {
    fn is_initialized(&self) -> bool {
        for v in &self.content_descriptors_to_exclude {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.content_descriptors_to_exclude)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.content_descriptors_to_exclude {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CStore_UserContentDescriptorPreferences_ContentDescriptor>>(
                "content_descriptors_to_exclude",
                |m: &CStore_UserContentDescriptorPreferences| { &m.content_descriptors_to_exclude },
                |m: &mut CStore_UserContentDescriptorPreferences| { &mut m.content_descriptors_to_exclude },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CStore_UserContentDescriptorPreferences>(
                "CStore_UserContentDescriptorPreferences",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CStore_UserContentDescriptorPreferences {
        static instance: ::protobuf::rt::LazyV2<CStore_UserContentDescriptorPreferences> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CStore_UserContentDescriptorPreferences::new)
    }
}

impl ::protobuf::Clear for CStore_UserContentDescriptorPreferences {
    fn clear(&mut self) {
        self.content_descriptors_to_exclude.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CStore_UserContentDescriptorPreferences {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CStore_UserContentDescriptorPreferences {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CStore_UserContentDescriptorPreferences_ContentDescriptor {
    // message fields
    content_descriptorid: ::std::option::Option<u32>,
    timestamp_added: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 content_descriptorid = 1;


    pub fn get_content_descriptorid(&self) -> u32 {
        self.content_descriptorid.unwrap_or(0)
    }
    pub fn clear_content_descriptorid(&mut self) {
        self.content_descriptorid = ::std::option::Option::None;
    }

    pub fn has_content_descriptorid(&self) -> bool {
        self.content_descriptorid.is_some()
    }

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

    // optional uint32 timestamp_added = 2;


    pub fn get_timestamp_added(&self) -> u32 {
        self.timestamp_added.unwrap_or(0)
    }
    pub fn clear_timestamp_added(&mut self) {
        self.timestamp_added = ::std::option::Option::None;
    }

    pub fn has_timestamp_added(&self) -> bool {
        self.timestamp_added.is_some()
    }

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

impl ::protobuf::Message for CStore_UserContentDescriptorPreferences_ContentDescriptor {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.content_descriptorid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.timestamp_added = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.content_descriptorid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.timestamp_added {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.content_descriptorid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.timestamp_added {
            os.write_uint32(2, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "content_descriptorid",
                |m: &CStore_UserContentDescriptorPreferences_ContentDescriptor| { &m.content_descriptorid },
                |m: &mut CStore_UserContentDescriptorPreferences_ContentDescriptor| { &mut m.content_descriptorid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "timestamp_added",
                |m: &CStore_UserContentDescriptorPreferences_ContentDescriptor| { &m.timestamp_added },
                |m: &mut CStore_UserContentDescriptorPreferences_ContentDescriptor| { &mut m.timestamp_added },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CStore_UserContentDescriptorPreferences_ContentDescriptor>(
                "CStore_UserContentDescriptorPreferences.ContentDescriptor",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CStore_UserContentDescriptorPreferences_ContentDescriptor {
        static instance: ::protobuf::rt::LazyV2<CStore_UserContentDescriptorPreferences_ContentDescriptor> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CStore_UserContentDescriptorPreferences_ContentDescriptor::new)
    }
}

impl ::protobuf::Clear for CStore_UserContentDescriptorPreferences_ContentDescriptor {
    fn clear(&mut self) {
        self.content_descriptorid = ::std::option::Option::None;
        self.timestamp_added = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CStore_UserContentDescriptorPreferences_ContentDescriptor {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CStore_UserContentDescriptorPreferences_ContentDescriptor {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CStore_GetStorePreferences_Response {
    // message fields
    pub preferences: ::protobuf::SingularPtrField<CStore_UserPreferences>,
    pub tag_preferences: ::protobuf::SingularPtrField<CStore_UserTagPreferences>,
    pub content_descriptor_preferences: ::protobuf::SingularPtrField<CStore_UserContentDescriptorPreferences>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional .CStore_UserPreferences preferences = 1;


    pub fn get_preferences(&self) -> &CStore_UserPreferences {
        self.preferences.as_ref().unwrap_or_else(|| <CStore_UserPreferences as ::protobuf::Message>::default_instance())
    }
    pub fn clear_preferences(&mut self) {
        self.preferences.clear();
    }

    pub fn has_preferences(&self) -> bool {
        self.preferences.is_some()
    }

    // Param is passed by value, moved
    pub fn set_preferences(&mut self, v: CStore_UserPreferences) {
        self.preferences = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_preferences(&mut self) -> &mut CStore_UserPreferences {
        if self.preferences.is_none() {
            self.preferences.set_default();
        }
        self.preferences.as_mut().unwrap()
    }

    // Take field
    pub fn take_preferences(&mut self) -> CStore_UserPreferences {
        self.preferences.take().unwrap_or_else(|| CStore_UserPreferences::new())
    }

    // optional .CStore_UserTagPreferences tag_preferences = 2;


    pub fn get_tag_preferences(&self) -> &CStore_UserTagPreferences {
        self.tag_preferences.as_ref().unwrap_or_else(|| <CStore_UserTagPreferences as ::protobuf::Message>::default_instance())
    }
    pub fn clear_tag_preferences(&mut self) {
        self.tag_preferences.clear();
    }

    pub fn has_tag_preferences(&self) -> bool {
        self.tag_preferences.is_some()
    }

    // Param is passed by value, moved
    pub fn set_tag_preferences(&mut self, v: CStore_UserTagPreferences) {
        self.tag_preferences = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tag_preferences(&mut self) -> &mut CStore_UserTagPreferences {
        if self.tag_preferences.is_none() {
            self.tag_preferences.set_default();
        }
        self.tag_preferences.as_mut().unwrap()
    }

    // Take field
    pub fn take_tag_preferences(&mut self) -> CStore_UserTagPreferences {
        self.tag_preferences.take().unwrap_or_else(|| CStore_UserTagPreferences::new())
    }

    // optional .CStore_UserContentDescriptorPreferences content_descriptor_preferences = 3;


    pub fn get_content_descriptor_preferences(&self) -> &CStore_UserContentDescriptorPreferences {
        self.content_descriptor_preferences.as_ref().unwrap_or_else(|| <CStore_UserContentDescriptorPreferences as ::protobuf::Message>::default_instance())
    }
    pub fn clear_content_descriptor_preferences(&mut self) {
        self.content_descriptor_preferences.clear();
    }

    pub fn has_content_descriptor_preferences(&self) -> bool {
        self.content_descriptor_preferences.is_some()
    }

    // Param is passed by value, moved
    pub fn set_content_descriptor_preferences(&mut self, v: CStore_UserContentDescriptorPreferences) {
        self.content_descriptor_preferences = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_content_descriptor_preferences(&mut self) -> &mut CStore_UserContentDescriptorPreferences {
        if self.content_descriptor_preferences.is_none() {
            self.content_descriptor_preferences.set_default();
        }
        self.content_descriptor_preferences.as_mut().unwrap()
    }

    // Take field
    pub fn take_content_descriptor_preferences(&mut self) -> CStore_UserContentDescriptorPreferences {
        self.content_descriptor_preferences.take().unwrap_or_else(|| CStore_UserContentDescriptorPreferences::new())
    }
}

impl ::protobuf::Message for CStore_GetStorePreferences_Response {
    fn is_initialized(&self) -> bool {
        for v in &self.preferences {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.tag_preferences {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.content_descriptor_preferences {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.preferences)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.tag_preferences)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.content_descriptor_preferences)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.preferences.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.tag_preferences.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.content_descriptor_preferences.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.preferences.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.tag_preferences.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.content_descriptor_preferences.as_ref() {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CStore_UserPreferences>>(
                "preferences",
                |m: &CStore_GetStorePreferences_Response| { &m.preferences },
                |m: &mut CStore_GetStorePreferences_Response| { &mut m.preferences },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CStore_UserTagPreferences>>(
                "tag_preferences",
                |m: &CStore_GetStorePreferences_Response| { &m.tag_preferences },
                |m: &mut CStore_GetStorePreferences_Response| { &mut m.tag_preferences },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CStore_UserContentDescriptorPreferences>>(
                "content_descriptor_preferences",
                |m: &CStore_GetStorePreferences_Response| { &m.content_descriptor_preferences },
                |m: &mut CStore_GetStorePreferences_Response| { &mut m.content_descriptor_preferences },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CStore_GetStorePreferences_Response>(
                "CStore_GetStorePreferences_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CStore_GetStorePreferences_Response {
        static instance: ::protobuf::rt::LazyV2<CStore_GetStorePreferences_Response> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CStore_GetStorePreferences_Response::new)
    }
}

impl ::protobuf::Clear for CStore_GetStorePreferences_Response {
    fn clear(&mut self) {
        self.preferences.clear();
        self.tag_preferences.clear();
        self.content_descriptor_preferences.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CStore_GetStorePreferences_Response {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CStore_GetStorePreferences_Response {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CStore_StorePreferencesChanged_Notification {
    // message fields
    pub preferences: ::protobuf::SingularPtrField<CStore_UserPreferences>,
    pub tag_preferences: ::protobuf::SingularPtrField<CStore_UserTagPreferences>,
    pub content_descriptor_preferences: ::protobuf::SingularPtrField<CStore_UserContentDescriptorPreferences>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional .CStore_UserPreferences preferences = 1;


    pub fn get_preferences(&self) -> &CStore_UserPreferences {
        self.preferences.as_ref().unwrap_or_else(|| <CStore_UserPreferences as ::protobuf::Message>::default_instance())
    }
    pub fn clear_preferences(&mut self) {
        self.preferences.clear();
    }

    pub fn has_preferences(&self) -> bool {
        self.preferences.is_some()
    }

    // Param is passed by value, moved
    pub fn set_preferences(&mut self, v: CStore_UserPreferences) {
        self.preferences = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_preferences(&mut self) -> &mut CStore_UserPreferences {
        if self.preferences.is_none() {
            self.preferences.set_default();
        }
        self.preferences.as_mut().unwrap()
    }

    // Take field
    pub fn take_preferences(&mut self) -> CStore_UserPreferences {
        self.preferences.take().unwrap_or_else(|| CStore_UserPreferences::new())
    }

    // optional .CStore_UserTagPreferences tag_preferences = 2;


    pub fn get_tag_preferences(&self) -> &CStore_UserTagPreferences {
        self.tag_preferences.as_ref().unwrap_or_else(|| <CStore_UserTagPreferences as ::protobuf::Message>::default_instance())
    }
    pub fn clear_tag_preferences(&mut self) {
        self.tag_preferences.clear();
    }

    pub fn has_tag_preferences(&self) -> bool {
        self.tag_preferences.is_some()
    }

    // Param is passed by value, moved
    pub fn set_tag_preferences(&mut self, v: CStore_UserTagPreferences) {
        self.tag_preferences = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tag_preferences(&mut self) -> &mut CStore_UserTagPreferences {
        if self.tag_preferences.is_none() {
            self.tag_preferences.set_default();
        }
        self.tag_preferences.as_mut().unwrap()
    }

    // Take field
    pub fn take_tag_preferences(&mut self) -> CStore_UserTagPreferences {
        self.tag_preferences.take().unwrap_or_else(|| CStore_UserTagPreferences::new())
    }

    // optional .CStore_UserContentDescriptorPreferences content_descriptor_preferences = 3;


    pub fn get_content_descriptor_preferences(&self) -> &CStore_UserContentDescriptorPreferences {
        self.content_descriptor_preferences.as_ref().unwrap_or_else(|| <CStore_UserContentDescriptorPreferences as ::protobuf::Message>::default_instance())
    }
    pub fn clear_content_descriptor_preferences(&mut self) {
        self.content_descriptor_preferences.clear();
    }

    pub fn has_content_descriptor_preferences(&self) -> bool {
        self.content_descriptor_preferences.is_some()
    }

    // Param is passed by value, moved
    pub fn set_content_descriptor_preferences(&mut self, v: CStore_UserContentDescriptorPreferences) {
        self.content_descriptor_preferences = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_content_descriptor_preferences(&mut self) -> &mut CStore_UserContentDescriptorPreferences {
        if self.content_descriptor_preferences.is_none() {
            self.content_descriptor_preferences.set_default();
        }
        self.content_descriptor_preferences.as_mut().unwrap()
    }

    // Take field
    pub fn take_content_descriptor_preferences(&mut self) -> CStore_UserContentDescriptorPreferences {
        self.content_descriptor_preferences.take().unwrap_or_else(|| CStore_UserContentDescriptorPreferences::new())
    }
}

impl ::protobuf::Message for CStore_StorePreferencesChanged_Notification {
    fn is_initialized(&self) -> bool {
        for v in &self.preferences {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.tag_preferences {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.content_descriptor_preferences {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.preferences)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.tag_preferences)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.content_descriptor_preferences)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.preferences.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.tag_preferences.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.content_descriptor_preferences.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.preferences.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.tag_preferences.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.content_descriptor_preferences.as_ref() {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CStore_UserPreferences>>(
                "preferences",
                |m: &CStore_StorePreferencesChanged_Notification| { &m.preferences },
                |m: &mut CStore_StorePreferencesChanged_Notification| { &mut m.preferences },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CStore_UserTagPreferences>>(
                "tag_preferences",
                |m: &CStore_StorePreferencesChanged_Notification| { &m.tag_preferences },
                |m: &mut CStore_StorePreferencesChanged_Notification| { &mut m.tag_preferences },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CStore_UserContentDescriptorPreferences>>(
                "content_descriptor_preferences",
                |m: &CStore_StorePreferencesChanged_Notification| { &m.content_descriptor_preferences },
                |m: &mut CStore_StorePreferencesChanged_Notification| { &mut m.content_descriptor_preferences },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CStore_StorePreferencesChanged_Notification>(
                "CStore_StorePreferencesChanged_Notification",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CStore_StorePreferencesChanged_Notification {
        static instance: ::protobuf::rt::LazyV2<CStore_StorePreferencesChanged_Notification> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CStore_StorePreferencesChanged_Notification::new)
    }
}

impl ::protobuf::Clear for CStore_StorePreferencesChanged_Notification {
    fn clear(&mut self) {
        self.preferences.clear();
        self.tag_preferences.clear();
        self.content_descriptor_preferences.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CStore_StorePreferencesChanged_Notification {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CStore_StorePreferencesChanged_Notification {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum EUserReviewScorePreference {
    k_EUserReviewScorePreference_Unset = 0,
    k_EUserReviewScorePreference_IncludeAll = 1,
    k_EUserReviewScorePreference_ExcludeBombs = 2,
}

impl ::protobuf::ProtobufEnum for EUserReviewScorePreference {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<EUserReviewScorePreference> {
        match value {
            0 => ::std::option::Option::Some(EUserReviewScorePreference::k_EUserReviewScorePreference_Unset),
            1 => ::std::option::Option::Some(EUserReviewScorePreference::k_EUserReviewScorePreference_IncludeAll),
            2 => ::std::option::Option::Some(EUserReviewScorePreference::k_EUserReviewScorePreference_ExcludeBombs),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [EUserReviewScorePreference] = &[
            EUserReviewScorePreference::k_EUserReviewScorePreference_Unset,
            EUserReviewScorePreference::k_EUserReviewScorePreference_IncludeAll,
            EUserReviewScorePreference::k_EUserReviewScorePreference_ExcludeBombs,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<EUserReviewScorePreference>("EUserReviewScorePreference", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for EUserReviewScorePreference {
}

impl ::std::default::Default for EUserReviewScorePreference {
    fn default() -> Self {
        EUserReviewScorePreference::k_EUserReviewScorePreference_Unset
    }
}

impl ::protobuf::reflect::ProtobufValue for EUserReviewScorePreference {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n%steammessages_store.steamclient.proto\x1a,steammessages_unified_base.\
    steamclient.proto\"?\n!CStore_GetMostPopularTags_Request\x12\x1a\n\x08la\
    nguage\x18\x01\x20\x01(\tR\x08language\"\x92\x01\n\"CStore_GetMostPopula\
    rTags_Response\x12;\n\x04tags\x18\x01\x20\x03(\x0b2'.CStore_GetMostPopul\
    arTags_Response.TagR\x04tags\x1a/\n\x03Tag\x12\x14\n\x05tagid\x18\x01\
    \x20\x01(\rR\x05tagid\x12\x12\n\x04name\x18\x02\x20\x01(\tR\x04name\"\\\
    \n&CStore_GetLocalizedNameForTags_Request\x12\x1a\n\x08language\x18\x01\
    \x20\x01(\tR\x08language\x12\x16\n\x06tagids\x18\x02\x20\x03(\rR\x06tagi\
    ds\"\xbf\x01\n'CStore_GetLocalizedNameForTags_Response\x12@\n\x04tags\
    \x18\x01\x20\x03(\x0b2,.CStore_GetLocalizedNameForTags_Response.TagR\x04\
    tags\x1aR\n\x03Tag\x12\x14\n\x05tagid\x18\x01\x20\x01(\rR\x05tagid\x12!\
    \n\x0cenglish_name\x18\x02\x20\x01(\tR\x0benglishName\x12\x12\n\x04name\
    \x18\x03\x20\x01(\tR\x04name\"$\n\"CStore_GetStorePreferences_Request\"\
    \x9d\x05\n\x16CStore_UserPreferences\x12)\n\x10primary_language\x18\x01\
    \x20\x01(\rR\x0fprimaryLanguage\x12/\n\x13secondary_languages\x18\x02\
    \x20\x01(\rR\x12secondaryLanguages\x12)\n\x10platform_windows\x18\x03\
    \x20\x01(\x08R\x0fplatformWindows\x12!\n\x0cplatform_mac\x18\x04\x20\x01\
    (\x08R\x0bplatformMac\x12%\n\x0eplatform_linux\x18\x05\x20\x01(\x08R\rpl\
    atformLinux\x12=\n\x1bhide_adult_content_violence\x18\x06\x20\x01(\x08R\
    \x18hideAdultContentViolence\x123\n\x16hide_adult_content_sex\x18\x07\
    \x20\x01(\x08R\x13hideAdultContentSex\x12+\n\x11timestamp_updated\x18\
    \x08\x20\x01(\rR\x10timestampUpdated\x120\n\x14hide_store_broadcast\x18\
    \t\x20\x01(\x08R\x12hideStoreBroadcast\x12w\n\x17review_score_preference\
    \x18\n\x20\x01(\x0e2\x1b.EUserReviewScorePreference:\"k_EUserReviewScore\
    Preference_UnsetR\x15reviewScorePreference\x12f\n0timestamp_content_desc\
    riptor_preferences_updated\x18\x0b\x20\x01(\x05R,timestampContentDescrip\
    torPreferencesUpdated\"\xbd\x01\n\x19CStore_UserTagPreferences\x12F\n\
    \x0ftags_to_exclude\x18\x01\x20\x03(\x0b2\x1e.CStore_UserTagPreferences.\
    TagR\rtagsToExclude\x1aX\n\x03Tag\x12\x14\n\x05tagid\x18\x01\x20\x01(\rR\
    \x05tagid\x12\x12\n\x04name\x18\x02\x20\x01(\tR\x04name\x12'\n\x0ftimest\
    amp_added\x18\x03\x20\x01(\rR\x0etimestampAdded\"\x9b\x02\n'CStore_UserC\
    ontentDescriptorPreferences\x12\x7f\n\x1econtent_descriptors_to_exclude\
    \x18\x01\x20\x03(\x0b2:.CStore_UserContentDescriptorPreferences.ContentD\
    escriptorR\x1bcontentDescriptorsToExclude\x1ao\n\x11ContentDescriptor\
    \x121\n\x14content_descriptorid\x18\x01\x20\x01(\rR\x13contentDescriptor\
    id\x12'\n\x0ftimestamp_added\x18\x02\x20\x01(\rR\x0etimestampAdded\"\x95\
    \x02\n#CStore_GetStorePreferences_Response\x129\n\x0bpreferences\x18\x01\
    \x20\x01(\x0b2\x17.CStore_UserPreferencesR\x0bpreferences\x12C\n\x0ftag_\
    preferences\x18\x02\x20\x01(\x0b2\x1a.CStore_UserTagPreferencesR\x0etagP\
    references\x12n\n\x1econtent_descriptor_preferences\x18\x03\x20\x01(\x0b\
    2(.CStore_UserContentDescriptorPreferencesR\x1ccontentDescriptorPreferen\
    ces\"\x9d\x02\n+CStore_StorePreferencesChanged_Notification\x129\n\x0bpr\
    eferences\x18\x01\x20\x01(\x0b2\x17.CStore_UserPreferencesR\x0bpreferenc\
    es\x12C\n\x0ftag_preferences\x18\x02\x20\x01(\x0b2\x1a.CStore_UserTagPre\
    ferencesR\x0etagPreferences\x12n\n\x1econtent_descriptor_preferences\x18\
    \x03\x20\x01(\x0b2(.CStore_UserContentDescriptorPreferencesR\x1ccontentD\
    escriptorPreferences*\xa0\x01\n\x1aEUserReviewScorePreference\x12&\n\"k_\
    EUserReviewScorePreference_Unset\x10\0\x12+\n'k_EUserReviewScorePreferen\
    ce_IncludeAll\x10\x01\x12-\n)k_EUserReviewScorePreference_ExcludeBombs\
    \x10\x022\x8e\x04\n\x05Store\x12\x92\x01\n\x12GetMostPopularTags\x12\".C\
    Store_GetMostPopularTags_Request\x1a#.CStore_GetMostPopularTags_Response\
    \"3\x82\xb5\x18/Get\x20all\x20whitelisted\x20tags,\x20with\x20localized\
    \x20names.\x12\x98\x01\n\x17GetLocalizedNameForTags\x12'.CStore_GetLocal\
    izedNameForTags_Request\x1a(.CStore_GetLocalizedNameForTags_Response\"*\
    \x82\xb5\x18&Gets\x20tag\x20names\x20in\x20a\x20different\x20language\
    \x12\xaf\x01\n\x13GetStorePreferences\x12#.CStore_GetStorePreferences_Re\
    quest\x1a$.CStore_GetStorePreferences_Response\"M\x82\xb5\x18IReturns\
    \x20the\x20desired\x20ratings\x20board\x20and\x20maximum\x20rating\x20to\
    \x20show\x20on\x20the\x20store\x1a#\x82\xb5\x18\x1fA\x20service\x20to\
    \x20access\x20store\x20data.2\xee\x01\n\x0bStoreClient\x12\xb1\x01\n\x1d\
    NotifyStorePreferencesChanged\x12,.CStore_StorePreferencesChanged_Notifi\
    cation\x1a\x0b.NoResponse\"U\x82\xb5\x18QNotification\x20from\x20server\
    \x20to\x20client\x20that\x20the\x20user's\x20store\x20preferences\x20hav\
    e\x20changed\x1a+\x82\xb5\x18#Steam\x20store\x20to\x20client\x20notifica\
    tions\xc0\xb5\x18\x02B\x03\x80\x01\x01J\xa4\x1b\n\x06\x12\x04\0\0m\x01\n\
    \t\n\x02\x03\0\x12\x03\0\06\n\x08\n\x01\x08\x12\x03\x02\0\"\n\t\n\x02\
    \x08\x10\x12\x03\x02\0\"\n\n\n\x02\x05\0\x12\x04\x04\0\x08\x01\n\n\n\x03\
    \x05\0\x01\x12\x03\x04\x05\x1f\n\x0b\n\x04\x05\0\x02\0\x12\x03\x05\x08/\
    \n\x0c\n\x05\x05\0\x02\0\x01\x12\x03\x05\x08*\n\x0c\n\x05\x05\0\x02\0\
    \x02\x12\x03\x05-.\n\x0b\n\x04\x05\0\x02\x01\x12\x03\x06\x084\n\x0c\n\
    \x05\x05\0\x02\x01\x01\x12\x03\x06\x08/\n\x0c\n\x05\x05\0\x02\x01\x02\
    \x12\x03\x0623\n\x0b\n\x04\x05\0\x02\x02\x12\x03\x07\x086\n\x0c\n\x05\
    \x05\0\x02\x02\x01\x12\x03\x07\x081\n\x0c\n\x05\x05\0\x02\x02\x02\x12\
    \x03\x0745\n\n\n\x02\x04\0\x12\x04\n\0\x0c\x01\n\n\n\x03\x04\0\x01\x12\
    \x03\n\x08)\n\x0b\n\x04\x04\0\x02\0\x12\x03\x0b\x08%\n\x0c\n\x05\x04\0\
    \x02\0\x04\x12\x03\x0b\x08\x10\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x0b\
    \x11\x17\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x0b\x18\x20\n\x0c\n\x05\x04\
    \0\x02\0\x03\x12\x03\x0b#$\n\n\n\x02\x04\x01\x12\x04\x0e\0\x15\x01\n\n\n\
    \x03\x04\x01\x01\x12\x03\x0e\x08*\n\x0c\n\x04\x04\x01\x03\0\x12\x04\x0f\
    \x08\x12\t\n\x0c\n\x05\x04\x01\x03\0\x01\x12\x03\x0f\x10\x13\n\r\n\x06\
    \x04\x01\x03\0\x02\0\x12\x03\x10\x10*\n\x0e\n\x07\x04\x01\x03\0\x02\0\
    \x04\x12\x03\x10\x10\x18\n\x0e\n\x07\x04\x01\x03\0\x02\0\x05\x12\x03\x10\
    \x19\x1f\n\x0e\n\x07\x04\x01\x03\0\x02\0\x01\x12\x03\x10\x20%\n\x0e\n\
    \x07\x04\x01\x03\0\x02\0\x03\x12\x03\x10()\n\r\n\x06\x04\x01\x03\0\x02\
    \x01\x12\x03\x11\x10)\n\x0e\n\x07\x04\x01\x03\0\x02\x01\x04\x12\x03\x11\
    \x10\x18\n\x0e\n\x07\x04\x01\x03\0\x02\x01\x05\x12\x03\x11\x19\x1f\n\x0e\
    \n\x07\x04\x01\x03\0\x02\x01\x01\x12\x03\x11\x20$\n\x0e\n\x07\x04\x01\
    \x03\0\x02\x01\x03\x12\x03\x11'(\n\x0b\n\x04\x04\x01\x02\0\x12\x03\x14\
    \x08B\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03\x14\x08\x10\n\x0c\n\x05\x04\
    \x01\x02\0\x06\x12\x03\x14\x118\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\
    \x149=\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03\x14@A\n\n\n\x02\x04\x02\x12\
    \x04\x17\0\x1a\x01\n\n\n\x03\x04\x02\x01\x12\x03\x17\x08.\n\x0b\n\x04\
    \x04\x02\x02\0\x12\x03\x18\x08%\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03\
    \x18\x08\x10\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03\x18\x11\x17\n\x0c\n\
    \x05\x04\x02\x02\0\x01\x12\x03\x18\x18\x20\n\x0c\n\x05\x04\x02\x02\0\x03\
    \x12\x03\x18#$\n\x0b\n\x04\x04\x02\x02\x01\x12\x03\x19\x08#\n\x0c\n\x05\
    \x04\x02\x02\x01\x04\x12\x03\x19\x08\x10\n\x0c\n\x05\x04\x02\x02\x01\x05\
    \x12\x03\x19\x11\x17\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03\x19\x18\x1e\
    \n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03\x19!\"\n\n\n\x02\x04\x03\x12\
    \x04\x1c\0$\x01\n\n\n\x03\x04\x03\x01\x12\x03\x1c\x08/\n\x0c\n\x04\x04\
    \x03\x03\0\x12\x04\x1d\x08!\t\n\x0c\n\x05\x04\x03\x03\0\x01\x12\x03\x1d\
    \x10\x13\n\r\n\x06\x04\x03\x03\0\x02\0\x12\x03\x1e\x10*\n\x0e\n\x07\x04\
    \x03\x03\0\x02\0\x04\x12\x03\x1e\x10\x18\n\x0e\n\x07\x04\x03\x03\0\x02\0\
    \x05\x12\x03\x1e\x19\x1f\n\x0e\n\x07\x04\x03\x03\0\x02\0\x01\x12\x03\x1e\
    \x20%\n\x0e\n\x07\x04\x03\x03\0\x02\0\x03\x12\x03\x1e()\n\r\n\x06\x04\
    \x03\x03\0\x02\x01\x12\x03\x1f\x101\n\x0e\n\x07\x04\x03\x03\0\x02\x01\
    \x04\x12\x03\x1f\x10\x18\n\x0e\n\x07\x04\x03\x03\0\x02\x01\x05\x12\x03\
    \x1f\x19\x1f\n\x0e\n\x07\x04\x03\x03\0\x02\x01\x01\x12\x03\x1f\x20,\n\
    \x0e\n\x07\x04\x03\x03\0\x02\x01\x03\x12\x03\x1f/0\n\r\n\x06\x04\x03\x03\
    \0\x02\x02\x12\x03\x20\x10)\n\x0e\n\x07\x04\x03\x03\0\x02\x02\x04\x12\
    \x03\x20\x10\x18\n\x0e\n\x07\x04\x03\x03\0\x02\x02\x05\x12\x03\x20\x19\
    \x1f\n\x0e\n\x07\x04\x03\x03\0\x02\x02\x01\x12\x03\x20\x20$\n\x0e\n\x07\
    \x04\x03\x03\0\x02\x02\x03\x12\x03\x20'(\n\x0b\n\x04\x04\x03\x02\0\x12\
    \x03#\x08G\n\x0c\n\x05\x04\x03\x02\0\x04\x12\x03#\x08\x10\n\x0c\n\x05\
    \x04\x03\x02\0\x06\x12\x03#\x11=\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03#>\
    B\n\x0c\n\x05\x04\x03\x02\0\x03\x12\x03#EF\n\n\n\x02\x04\x04\x12\x04&\0'\
    \x01\n\n\n\x03\x04\x04\x01\x12\x03&\x08*\n\n\n\x02\x04\x05\x12\x04)\05\
    \x01\n\n\n\x03\x04\x05\x01\x12\x03)\x08\x1e\n\x0b\n\x04\x04\x05\x02\0\
    \x12\x03*\x08-\n\x0c\n\x05\x04\x05\x02\0\x04\x12\x03*\x08\x10\n\x0c\n\
    \x05\x04\x05\x02\0\x05\x12\x03*\x11\x17\n\x0c\n\x05\x04\x05\x02\0\x01\
    \x12\x03*\x18(\n\x0c\n\x05\x04\x05\x02\0\x03\x12\x03*+,\n\x0b\n\x04\x04\
    \x05\x02\x01\x12\x03+\x080\n\x0c\n\x05\x04\x05\x02\x01\x04\x12\x03+\x08\
    \x10\n\x0c\n\x05\x04\x05\x02\x01\x05\x12\x03+\x11\x17\n\x0c\n\x05\x04\
    \x05\x02\x01\x01\x12\x03+\x18+\n\x0c\n\x05\x04\x05\x02\x01\x03\x12\x03+.\
    /\n\x0b\n\x04\x04\x05\x02\x02\x12\x03,\x08+\n\x0c\n\x05\x04\x05\x02\x02\
    \x04\x12\x03,\x08\x10\n\x0c\n\x05\x04\x05\x02\x02\x05\x12\x03,\x11\x15\n\
    \x0c\n\x05\x04\x05\x02\x02\x01\x12\x03,\x16&\n\x0c\n\x05\x04\x05\x02\x02\
    \x03\x12\x03,)*\n\x0b\n\x04\x04\x05\x02\x03\x12\x03-\x08'\n\x0c\n\x05\
    \x04\x05\x02\x03\x04\x12\x03-\x08\x10\n\x0c\n\x05\x04\x05\x02\x03\x05\
    \x12\x03-\x11\x15\n\x0c\n\x05\x04\x05\x02\x03\x01\x12\x03-\x16\"\n\x0c\n\
    \x05\x04\x05\x02\x03\x03\x12\x03-%&\n\x0b\n\x04\x04\x05\x02\x04\x12\x03.\
    \x08)\n\x0c\n\x05\x04\x05\x02\x04\x04\x12\x03.\x08\x10\n\x0c\n\x05\x04\
    \x05\x02\x04\x05\x12\x03.\x11\x15\n\x0c\n\x05\x04\x05\x02\x04\x01\x12\
    \x03.\x16$\n\x0c\n\x05\x04\x05\x02\x04\x03\x12\x03.'(\n\x0b\n\x04\x04\
    \x05\x02\x05\x12\x03/\x086\n\x0c\n\x05\x04\x05\x02\x05\x04\x12\x03/\x08\
    \x10\n\x0c\n\x05\x04\x05\x02\x05\x05\x12\x03/\x11\x15\n\x0c\n\x05\x04\
    \x05\x02\x05\x01\x12\x03/\x161\n\x0c\n\x05\x04\x05\x02\x05\x03\x12\x03/4\
    5\n\x0b\n\x04\x04\x05\x02\x06\x12\x030\x081\n\x0c\n\x05\x04\x05\x02\x06\
    \x04\x12\x030\x08\x10\n\x0c\n\x05\x04\x05\x02\x06\x05\x12\x030\x11\x15\n\
    \x0c\n\x05\x04\x05\x02\x06\x01\x12\x030\x16,\n\x0c\n\x05\x04\x05\x02\x06\
    \x03\x12\x030/0\n\x0b\n\x04\x04\x05\x02\x07\x12\x031\x08.\n\x0c\n\x05\
    \x04\x05\x02\x07\x04\x12\x031\x08\x10\n\x0c\n\x05\x04\x05\x02\x07\x05\
    \x12\x031\x11\x17\n\x0c\n\x05\x04\x05\x02\x07\x01\x12\x031\x18)\n\x0c\n\
    \x05\x04\x05\x02\x07\x03\x12\x031,-\n\x0b\n\x04\x04\x05\x02\x08\x12\x032\
    \x08/\n\x0c\n\x05\x04\x05\x02\x08\x04\x12\x032\x08\x10\n\x0c\n\x05\x04\
    \x05\x02\x08\x05\x12\x032\x11\x15\n\x0c\n\x05\x04\x05\x02\x08\x01\x12\
    \x032\x16*\n\x0c\n\x05\x04\x05\x02\x08\x03\x12\x032-.\n\x0b\n\x04\x04\
    \x05\x02\t\x12\x033\x08y\n\x0c\n\x05\x04\x05\x02\t\x04\x12\x033\x08\x10\
    \n\x0c\n\x05\x04\x05\x02\t\x06\x12\x033\x11,\n\x0c\n\x05\x04\x05\x02\t\
    \x01\x12\x033-D\n\x0c\n\x05\x04\x05\x02\t\x03\x12\x033GI\n\x0c\n\x05\x04\
    \x05\x02\t\x08\x12\x033Jx\n\x0c\n\x05\x04\x05\x02\t\x07\x12\x033Uw\n\x0b\
    \n\x04\x04\x05\x02\n\x12\x034\x08M\n\x0c\n\x05\x04\x05\x02\n\x04\x12\x03\
    4\x08\x10\n\x0c\n\x05\x04\x05\x02\n\x05\x12\x034\x11\x16\n\x0c\n\x05\x04\
    \x05\x02\n\x01\x12\x034\x17G\n\x0c\n\x05\x04\x05\x02\n\x03\x12\x034JL\n\
    \n\n\x02\x04\x06\x12\x047\0?\x01\n\n\n\x03\x04\x06\x01\x12\x037\x08!\n\
    \x0c\n\x04\x04\x06\x03\0\x12\x048\x08<\t\n\x0c\n\x05\x04\x06\x03\0\x01\
    \x12\x038\x10\x13\n\r\n\x06\x04\x06\x03\0\x02\0\x12\x039\x10*\n\x0e\n\
    \x07\x04\x06\x03\0\x02\0\x04\x12\x039\x10\x18\n\x0e\n\x07\x04\x06\x03\0\
    \x02\0\x05\x12\x039\x19\x1f\n\x0e\n\x07\x04\x06\x03\0\x02\0\x01\x12\x039\
    \x20%\n\x0e\n\x07\x04\x06\x03\0\x02\0\x03\x12\x039()\n\r\n\x06\x04\x06\
    \x03\0\x02\x01\x12\x03:\x10)\n\x0e\n\x07\x04\x06\x03\0\x02\x01\x04\x12\
    \x03:\x10\x18\n\x0e\n\x07\x04\x06\x03\0\x02\x01\x05\x12\x03:\x19\x1f\n\
    \x0e\n\x07\x04\x06\x03\0\x02\x01\x01\x12\x03:\x20$\n\x0e\n\x07\x04\x06\
    \x03\0\x02\x01\x03\x12\x03:'(\n\r\n\x06\x04\x06\x03\0\x02\x02\x12\x03;\
    \x104\n\x0e\n\x07\x04\x06\x03\0\x02\x02\x04\x12\x03;\x10\x18\n\x0e\n\x07\
    \x04\x06\x03\0\x02\x02\x05\x12\x03;\x19\x1f\n\x0e\n\x07\x04\x06\x03\0\
    \x02\x02\x01\x12\x03;\x20/\n\x0e\n\x07\x04\x06\x03\0\x02\x02\x03\x12\x03\
    ;23\n\x0b\n\x04\x04\x06\x02\0\x12\x03>\x08D\n\x0c\n\x05\x04\x06\x02\0\
    \x04\x12\x03>\x08\x10\n\x0c\n\x05\x04\x06\x02\0\x06\x12\x03>\x11/\n\x0c\
    \n\x05\x04\x06\x02\0\x01\x12\x03>0?\n\x0c\n\x05\x04\x06\x02\0\x03\x12\
    \x03>BC\n\n\n\x02\x04\x07\x12\x04A\0H\x01\n\n\n\x03\x04\x07\x01\x12\x03A\
    \x08/\n\x0c\n\x04\x04\x07\x03\0\x12\x04B\x08E\t\n\x0c\n\x05\x04\x07\x03\
    \0\x01\x12\x03B\x10!\n\r\n\x06\x04\x07\x03\0\x02\0\x12\x03C\x109\n\x0e\n\
    \x07\x04\x07\x03\0\x02\0\x04\x12\x03C\x10\x18\n\x0e\n\x07\x04\x07\x03\0\
    \x02\0\x05\x12\x03C\x19\x1f\n\x0e\n\x07\x04\x07\x03\0\x02\0\x01\x12\x03C\
    \x204\n\x0e\n\x07\x04\x07\x03\0\x02\0\x03\x12\x03C78\n\r\n\x06\x04\x07\
    \x03\0\x02\x01\x12\x03D\x104\n\x0e\n\x07\x04\x07\x03\0\x02\x01\x04\x12\
    \x03D\x10\x18\n\x0e\n\x07\x04\x07\x03\0\x02\x01\x05\x12\x03D\x19\x1f\n\
    \x0e\n\x07\x04\x07\x03\0\x02\x01\x01\x12\x03D\x20/\n\x0e\n\x07\x04\x07\
    \x03\0\x02\x01\x03\x12\x03D23\n\x0b\n\x04\x04\x07\x02\0\x12\x03G\x08o\n\
    \x0c\n\x05\x04\x07\x02\0\x04\x12\x03G\x08\x10\n\x0c\n\x05\x04\x07\x02\0\
    \x06\x12\x03G\x11K\n\x0c\n\x05\x04\x07\x02\0\x01\x12\x03GLj\n\x0c\n\x05\
    \x04\x07\x02\0\x03\x12\x03Gmn\n\n\n\x02\x04\x08\x12\x04J\0N\x01\n\n\n\
    \x03\x04\x08\x01\x12\x03J\x08+\n\x0b\n\x04\x04\x08\x02\0\x12\x03K\x089\n\
    \x0c\n\x05\x04\x08\x02\0\x04\x12\x03K\x08\x10\n\x0c\n\x05\x04\x08\x02\0\
    \x06\x12\x03K\x11(\n\x0c\n\x05\x04\x08\x02\0\x01\x12\x03K)4\n\x0c\n\x05\
    \x04\x08\x02\0\x03\x12\x03K78\n\x0b\n\x04\x04\x08\x02\x01\x12\x03L\x08@\
    \n\x0c\n\x05\x04\x08\x02\x01\x04\x12\x03L\x08\x10\n\x0c\n\x05\x04\x08\
    \x02\x01\x06\x12\x03L\x11+\n\x0c\n\x05\x04\x08\x02\x01\x01\x12\x03L,;\n\
    \x0c\n\x05\x04\x08\x02\x01\x03\x12\x03L>?\n\x0b\n\x04\x04\x08\x02\x02\
    \x12\x03M\x08]\n\x0c\n\x05\x04\x08\x02\x02\x04\x12\x03M\x08\x10\n\x0c\n\
    \x05\x04\x08\x02\x02\x06\x12\x03M\x119\n\x0c\n\x05\x04\x08\x02\x02\x01\
    \x12\x03M:X\n\x0c\n\x05\x04\x08\x02\x02\x03\x12\x03M[\\\n\n\n\x02\x04\t\
    \x12\x04P\0T\x01\n\n\n\x03\x04\t\x01\x12\x03P\x083\n\x0b\n\x04\x04\t\x02\
    \0\x12\x03Q\x089\n\x0c\n\x05\x04\t\x02\0\x04\x12\x03Q\x08\x10\n\x0c\n\
    \x05\x04\t\x02\0\x06\x12\x03Q\x11(\n\x0c\n\x05\x04\t\x02\0\x01\x12\x03Q)\
    4\n\x0c\n\x05\x04\t\x02\0\x03\x12\x03Q78\n\x0b\n\x04\x04\t\x02\x01\x12\
    \x03R\x08@\n\x0c\n\x05\x04\t\x02\x01\x04\x12\x03R\x08\x10\n\x0c\n\x05\
    \x04\t\x02\x01\x06\x12\x03R\x11+\n\x0c\n\x05\x04\t\x02\x01\x01\x12\x03R,\
    ;\n\x0c\n\x05\x04\t\x02\x01\x03\x12\x03R>?\n\x0b\n\x04\x04\t\x02\x02\x12\
    \x03S\x08]\n\x0c\n\x05\x04\t\x02\x02\x04\x12\x03S\x08\x10\n\x0c\n\x05\
    \x04\t\x02\x02\x06\x12\x03S\x119\n\x0c\n\x05\x04\t\x02\x02\x01\x12\x03S:\
    X\n\x0c\n\x05\x04\t\x02\x02\x03\x12\x03S[\\\n\n\n\x02\x06\0\x12\x04V\0d\
    \x01\n\n\n\x03\x06\0\x01\x12\x03V\x08\r\n\n\n\x03\x06\0\x03\x12\x03W\x08\
    I\n\r\n\x06\x06\0\x03\xd0\x86\x03\x12\x03W\x08I\n\x0c\n\x04\x06\0\x02\0\
    \x12\x04Y\x08[\t\n\x0c\n\x05\x06\0\x02\0\x01\x12\x03Y\x0c\x1e\n\x0c\n\
    \x05\x06\0\x02\0\x02\x12\x03Y\x20B\n\x0c\n\x05\x06\0\x02\0\x03\x12\x03YM\
    p\n\x0c\n\x05\x06\0\x02\0\x04\x12\x03Z\x10`\n\x0f\n\x08\x06\0\x02\0\x04\
    \xd0\x86\x03\x12\x03Z\x10`\n\x0c\n\x04\x06\0\x02\x01\x12\x04]\x08_\t\n\
    \x0c\n\x05\x06\0\x02\x01\x01\x12\x03]\x0c#\n\x0c\n\x05\x06\0\x02\x01\x02\
    \x12\x03]%L\n\x0c\n\x05\x06\0\x02\x01\x03\x12\x03]W\x7f\n\x0c\n\x05\x06\
    \0\x02\x01\x04\x12\x03^\x10W\n\x0f\n\x08\x06\0\x02\x01\x04\xd0\x86\x03\
    \x12\x03^\x10W\n\x0c\n\x04\x06\0\x02\x02\x12\x04a\x08c\t\n\x0c\n\x05\x06\
    \0\x02\x02\x01\x12\x03a\x0c\x1f\n\x0c\n\x05\x06\0\x02\x02\x02\x12\x03a!D\
    \n\x0c\n\x05\x06\0\x02\x02\x03\x12\x03aOs\n\x0c\n\x05\x06\0\x02\x02\x04\
    \x12\x03b\x10z\n\x0f\n\x08\x06\0\x02\x02\x04\xd0\x86\x03\x12\x03b\x10z\n\
    \n\n\x02\x06\x01\x12\x04f\0m\x01\n\n\n\x03\x06\x01\x01\x12\x03f\x08\x13\
    \n\n\n\x03\x06\x01\x03\x12\x03g\x08M\n\r\n\x06\x06\x01\x03\xd0\x86\x03\
    \x12\x03g\x08M\n\n\n\x03\x06\x01\x03\x12\x03h\x08K\n\r\n\x06\x06\x01\x03\
    \xd8\x86\x03\x12\x03h\x08K\n\x0c\n\x04\x06\x01\x02\0\x12\x04j\x08l\t\n\
    \x0c\n\x05\x06\x01\x02\0\x01\x12\x03j\x0c)\n\x0c\n\x05\x06\x01\x02\0\x02\
    \x12\x03j+W\n\x0c\n\x05\x06\x01\x02\0\x03\x12\x03jbm\n\r\n\x05\x06\x01\
    \x02\0\x04\x12\x04k\x10\x82\x01\n\x10\n\x08\x06\x01\x02\0\x04\xd0\x86\
    \x03\x12\x04k\x10\x82\x01\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}