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_econ.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 CEcon_GetTradeOfferAccessToken_Request {
    // message fields
    generate_new_token: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bool generate_new_token = 1;


    pub fn get_generate_new_token(&self) -> bool {
        self.generate_new_token.unwrap_or(false)
    }
    pub fn clear_generate_new_token(&mut self) {
        self.generate_new_token = ::std::option::Option::None;
    }

    pub fn has_generate_new_token(&self) -> bool {
        self.generate_new_token.is_some()
    }

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

impl ::protobuf::Message for CEcon_GetTradeOfferAccessToken_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 => {
                    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.generate_new_token = ::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.generate_new_token {
            my_size += 2;
        }
        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.generate_new_token {
            os.write_bool(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() -> CEcon_GetTradeOfferAccessToken_Request {
        CEcon_GetTradeOfferAccessToken_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_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "generate_new_token",
                |m: &CEcon_GetTradeOfferAccessToken_Request| { &m.generate_new_token },
                |m: &mut CEcon_GetTradeOfferAccessToken_Request| { &mut m.generate_new_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CEcon_GetTradeOfferAccessToken_Request>(
                "CEcon_GetTradeOfferAccessToken_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional string trade_offer_access_token = 1;


    pub fn get_trade_offer_access_token(&self) -> &str {
        match self.trade_offer_access_token.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_trade_offer_access_token(&mut self) {
        self.trade_offer_access_token.clear();
    }

    pub fn has_trade_offer_access_token(&self) -> bool {
        self.trade_offer_access_token.is_some()
    }

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

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

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

impl ::protobuf::Message for CEcon_GetTradeOfferAccessToken_Response {
    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.trade_offer_access_token)?;
                },
                _ => {
                    ::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.trade_offer_access_token.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.trade_offer_access_token.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() -> CEcon_GetTradeOfferAccessToken_Response {
        CEcon_GetTradeOfferAccessToken_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_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "trade_offer_access_token",
                |m: &CEcon_GetTradeOfferAccessToken_Response| { &m.trade_offer_access_token },
                |m: &mut CEcon_GetTradeOfferAccessToken_Response| { &mut m.trade_offer_access_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CEcon_GetTradeOfferAccessToken_Response>(
                "CEcon_GetTradeOfferAccessToken_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional string return_url = 1;


    pub fn get_return_url(&self) -> &str {
        match self.return_url.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_return_url(&mut self) {
        self.return_url.clear();
    }

    pub fn has_return_url(&self) -> bool {
        self.return_url.is_some()
    }

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

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

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

impl ::protobuf::Message for CEcon_ClientGetItemShopOverlayAuthURL_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.return_url)?;
                },
                _ => {
                    ::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.return_url.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.return_url.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() -> CEcon_ClientGetItemShopOverlayAuthURL_Request {
        CEcon_ClientGetItemShopOverlayAuthURL_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>(
                "return_url",
                |m: &CEcon_ClientGetItemShopOverlayAuthURL_Request| { &m.return_url },
                |m: &mut CEcon_ClientGetItemShopOverlayAuthURL_Request| { &mut m.return_url },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CEcon_ClientGetItemShopOverlayAuthURL_Request>(
                "CEcon_ClientGetItemShopOverlayAuthURL_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional string url = 1;


    pub fn get_url(&self) -> &str {
        match self.url.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_url(&mut self) {
        self.url.clear();
    }

    pub fn has_url(&self) -> bool {
        self.url.is_some()
    }

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

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

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

impl ::protobuf::Message for CEcon_ClientGetItemShopOverlayAuthURL_Response {
    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.url)?;
                },
                _ => {
                    ::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.url.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.url.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() -> CEcon_ClientGetItemShopOverlayAuthURL_Response {
        CEcon_ClientGetItemShopOverlayAuthURL_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_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "url",
                |m: &CEcon_ClientGetItemShopOverlayAuthURL_Response| { &m.url },
                |m: &mut CEcon_ClientGetItemShopOverlayAuthURL_Response| { &mut m.url },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CEcon_ClientGetItemShopOverlayAuthURL_Response>(
                "CEcon_ClientGetItemShopOverlayAuthURL_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CEcon_GetAssetClassInfo_Request {
    // message fields
    language: ::protobuf::SingularField<::std::string::String>,
    appid: ::std::option::Option<u32>,
    pub classes: ::protobuf::RepeatedField<CEcon_GetAssetClassInfo_Request_Class>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

impl CEcon_GetAssetClassInfo_Request {
    pub fn new() -> CEcon_GetAssetClassInfo_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())
    }

    // optional uint32 appid = 2;


    pub fn get_appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }
    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

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

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

    // repeated .CEcon_GetAssetClassInfo_Request.Class classes = 3;


    pub fn get_classes(&self) -> &[CEcon_GetAssetClassInfo_Request_Class] {
        &self.classes
    }
    pub fn clear_classes(&mut self) {
        self.classes.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_classes(&mut self) -> &mut ::protobuf::RepeatedField<CEcon_GetAssetClassInfo_Request_Class> {
        &mut self.classes
    }

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

impl ::protobuf::Message for CEcon_GetAssetClassInfo_Request {
    fn is_initialized(&self) -> bool {
        for v in &self.classes {
            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_string_into(wire_type, is, &mut self.language)?;
                },
                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.appid = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.classes)?;
                },
                _ => {
                    ::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);
        }
        if let Some(v) = self.appid {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.classes {
            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<()> {
        if let Some(ref v) = self.language.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(2, v)?;
        }
        for v in &self.classes {
            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() -> CEcon_GetAssetClassInfo_Request {
        CEcon_GetAssetClassInfo_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: &CEcon_GetAssetClassInfo_Request| { &m.language },
                |m: &mut CEcon_GetAssetClassInfo_Request| { &mut m.language },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "appid",
                |m: &CEcon_GetAssetClassInfo_Request| { &m.appid },
                |m: &mut CEcon_GetAssetClassInfo_Request| { &mut m.appid },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CEcon_GetAssetClassInfo_Request_Class>>(
                "classes",
                |m: &CEcon_GetAssetClassInfo_Request| { &m.classes },
                |m: &mut CEcon_GetAssetClassInfo_Request| { &mut m.classes },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CEcon_GetAssetClassInfo_Request>(
                "CEcon_GetAssetClassInfo_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CEcon_GetAssetClassInfo_Request {
    fn clear(&mut self) {
        self.language.clear();
        self.appid = ::std::option::Option::None;
        self.classes.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CEcon_GetAssetClassInfo_Request_Class {
    // message fields
    classid: ::std::option::Option<u64>,
    instanceid: ::std::option::Option<u64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint64 classid = 1;


    pub fn get_classid(&self) -> u64 {
        self.classid.unwrap_or(0)
    }
    pub fn clear_classid(&mut self) {
        self.classid = ::std::option::Option::None;
    }

    pub fn has_classid(&self) -> bool {
        self.classid.is_some()
    }

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

    // optional uint64 instanceid = 2;


    pub fn get_instanceid(&self) -> u64 {
        self.instanceid.unwrap_or(0)
    }
    pub fn clear_instanceid(&mut self) {
        self.instanceid = ::std::option::Option::None;
    }

    pub fn has_instanceid(&self) -> bool {
        self.instanceid.is_some()
    }

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

impl ::protobuf::Message for CEcon_GetAssetClassInfo_Request_Class {
    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_uint64()?;
                    self.classid = ::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_uint64()?;
                    self.instanceid = ::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.classid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.instanceid {
            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.classid {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.instanceid {
            os.write_uint64(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() -> CEcon_GetAssetClassInfo_Request_Class {
        CEcon_GetAssetClassInfo_Request_Class::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::ProtobufTypeUint64>(
                "classid",
                |m: &CEcon_GetAssetClassInfo_Request_Class| { &m.classid },
                |m: &mut CEcon_GetAssetClassInfo_Request_Class| { &mut m.classid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "instanceid",
                |m: &CEcon_GetAssetClassInfo_Request_Class| { &m.instanceid },
                |m: &mut CEcon_GetAssetClassInfo_Request_Class| { &mut m.instanceid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CEcon_GetAssetClassInfo_Request_Class>(
                "CEcon_GetAssetClassInfo_Request.Class",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CEcon_GetAssetClassInfo_Request_Class {
    fn clear(&mut self) {
        self.classid = ::std::option::Option::None;
        self.instanceid = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional string type = 1;


    pub fn get_field_type(&self) -> &str {
        match self.field_type.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_field_type(&mut self) {
        self.field_type.clear();
    }

    pub fn has_field_type(&self) -> bool {
        self.field_type.is_some()
    }

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

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

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

    // optional string value = 2;


    pub fn get_value(&self) -> &str {
        match self.value.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

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

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

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

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

    // optional string color = 3;


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

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

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

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

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

    // optional string label = 4;


    pub fn get_label(&self) -> &str {
        match self.label.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_label(&mut self) {
        self.label.clear();
    }

    pub fn has_label(&self) -> bool {
        self.label.is_some()
    }

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

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

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

impl ::protobuf::Message for CEconItem_DescriptionLine {
    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.field_type)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.value)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.color)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.label)?;
                },
                _ => {
                    ::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.field_type.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.value.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(ref v) = self.color.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(ref v) = self.label.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &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.field_type.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.value.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(ref v) = self.color.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(ref v) = self.label.as_ref() {
            os.write_string(4, &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() -> CEconItem_DescriptionLine {
        CEconItem_DescriptionLine::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>(
                "type",
                |m: &CEconItem_DescriptionLine| { &m.field_type },
                |m: &mut CEconItem_DescriptionLine| { &mut m.field_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "value",
                |m: &CEconItem_DescriptionLine| { &m.value },
                |m: &mut CEconItem_DescriptionLine| { &mut m.value },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "color",
                |m: &CEconItem_DescriptionLine| { &m.color },
                |m: &mut CEconItem_DescriptionLine| { &mut m.color },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "label",
                |m: &CEconItem_DescriptionLine| { &m.label },
                |m: &mut CEconItem_DescriptionLine| { &mut m.label },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CEconItem_DescriptionLine>(
                "CEconItem_DescriptionLine",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CEconItem_DescriptionLine {
    fn clear(&mut self) {
        self.field_type.clear();
        self.value.clear();
        self.color.clear();
        self.label.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CEconItem_Action {
    // message fields
    link: ::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 CEconItem_Action {
    fn default() -> &'a CEconItem_Action {
        <CEconItem_Action as ::protobuf::Message>::default_instance()
    }
}

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

    // optional string link = 1;


    pub fn get_link(&self) -> &str {
        match self.link.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_link(&mut self) {
        self.link.clear();
    }

    pub fn has_link(&self) -> bool {
        self.link.is_some()
    }

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

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

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

    // 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 CEconItem_Action {
    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.link)?;
                },
                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(ref v) = self.link.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        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(ref v) = self.link.as_ref() {
            os.write_string(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() -> CEconItem_Action {
        CEconItem_Action::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>(
                "link",
                |m: &CEconItem_Action| { &m.link },
                |m: &mut CEconItem_Action| { &mut m.link },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &CEconItem_Action| { &m.name },
                |m: &mut CEconItem_Action| { &mut m.name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CEconItem_Action>(
                "CEconItem_Action",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CEconItem_Description {
    // message fields
    appid: ::std::option::Option<i32>,
    classid: ::std::option::Option<u64>,
    instanceid: ::std::option::Option<u64>,
    currency: ::std::option::Option<bool>,
    background_color: ::protobuf::SingularField<::std::string::String>,
    icon_url: ::protobuf::SingularField<::std::string::String>,
    icon_url_large: ::protobuf::SingularField<::std::string::String>,
    pub descriptions: ::protobuf::RepeatedField<CEconItem_DescriptionLine>,
    tradable: ::std::option::Option<bool>,
    pub actions: ::protobuf::RepeatedField<CEconItem_Action>,
    pub owner_descriptions: ::protobuf::RepeatedField<CEconItem_DescriptionLine>,
    pub owner_actions: ::protobuf::RepeatedField<CEconItem_Action>,
    pub fraudwarnings: ::protobuf::RepeatedField<::std::string::String>,
    name: ::protobuf::SingularField<::std::string::String>,
    name_color: ::protobuf::SingularField<::std::string::String>,
    field_type: ::protobuf::SingularField<::std::string::String>,
    market_name: ::protobuf::SingularField<::std::string::String>,
    market_hash_name: ::protobuf::SingularField<::std::string::String>,
    market_fee: ::protobuf::SingularField<::std::string::String>,
    market_fee_app: ::std::option::Option<i32>,
    pub contained_item: ::protobuf::SingularPtrField<CEconItem_Description>,
    pub market_actions: ::protobuf::RepeatedField<CEconItem_Action>,
    commodity: ::std::option::Option<bool>,
    market_tradable_restriction: ::std::option::Option<i32>,
    market_marketable_restriction: ::std::option::Option<i32>,
    marketable: ::std::option::Option<bool>,
    pub tags: ::protobuf::RepeatedField<CEconItem_Tag>,
    item_expiration: ::protobuf::SingularField<::std::string::String>,
    market_buy_country_restriction: ::protobuf::SingularField<::std::string::String>,
    market_sell_country_restriction: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional int32 appid = 1;


    pub fn get_appid(&self) -> i32 {
        self.appid.unwrap_or(0)
    }
    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

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

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

    // optional uint64 classid = 2;


    pub fn get_classid(&self) -> u64 {
        self.classid.unwrap_or(0)
    }
    pub fn clear_classid(&mut self) {
        self.classid = ::std::option::Option::None;
    }

    pub fn has_classid(&self) -> bool {
        self.classid.is_some()
    }

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

    // optional uint64 instanceid = 3;


    pub fn get_instanceid(&self) -> u64 {
        self.instanceid.unwrap_or(0)
    }
    pub fn clear_instanceid(&mut self) {
        self.instanceid = ::std::option::Option::None;
    }

    pub fn has_instanceid(&self) -> bool {
        self.instanceid.is_some()
    }

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

    // optional bool currency = 4;


    pub fn get_currency(&self) -> bool {
        self.currency.unwrap_or(false)
    }
    pub fn clear_currency(&mut self) {
        self.currency = ::std::option::Option::None;
    }

    pub fn has_currency(&self) -> bool {
        self.currency.is_some()
    }

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

    // optional string background_color = 5;


    pub fn get_background_color(&self) -> &str {
        match self.background_color.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_background_color(&mut self) {
        self.background_color.clear();
    }

    pub fn has_background_color(&self) -> bool {
        self.background_color.is_some()
    }

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

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

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

    // optional string icon_url = 6;


    pub fn get_icon_url(&self) -> &str {
        match self.icon_url.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_icon_url(&mut self) {
        self.icon_url.clear();
    }

    pub fn has_icon_url(&self) -> bool {
        self.icon_url.is_some()
    }

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

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

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

    // optional string icon_url_large = 7;


    pub fn get_icon_url_large(&self) -> &str {
        match self.icon_url_large.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_icon_url_large(&mut self) {
        self.icon_url_large.clear();
    }

    pub fn has_icon_url_large(&self) -> bool {
        self.icon_url_large.is_some()
    }

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

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

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

    // repeated .CEconItem_DescriptionLine descriptions = 8;


    pub fn get_descriptions(&self) -> &[CEconItem_DescriptionLine] {
        &self.descriptions
    }
    pub fn clear_descriptions(&mut self) {
        self.descriptions.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_descriptions(&mut self) -> &mut ::protobuf::RepeatedField<CEconItem_DescriptionLine> {
        &mut self.descriptions
    }

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

    // optional bool tradable = 9;


    pub fn get_tradable(&self) -> bool {
        self.tradable.unwrap_or(false)
    }
    pub fn clear_tradable(&mut self) {
        self.tradable = ::std::option::Option::None;
    }

    pub fn has_tradable(&self) -> bool {
        self.tradable.is_some()
    }

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

    // repeated .CEconItem_Action actions = 10;


    pub fn get_actions(&self) -> &[CEconItem_Action] {
        &self.actions
    }
    pub fn clear_actions(&mut self) {
        self.actions.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_actions(&mut self) -> &mut ::protobuf::RepeatedField<CEconItem_Action> {
        &mut self.actions
    }

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

    // repeated .CEconItem_DescriptionLine owner_descriptions = 11;


    pub fn get_owner_descriptions(&self) -> &[CEconItem_DescriptionLine] {
        &self.owner_descriptions
    }
    pub fn clear_owner_descriptions(&mut self) {
        self.owner_descriptions.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_owner_descriptions(&mut self) -> &mut ::protobuf::RepeatedField<CEconItem_DescriptionLine> {
        &mut self.owner_descriptions
    }

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

    // repeated .CEconItem_Action owner_actions = 12;


    pub fn get_owner_actions(&self) -> &[CEconItem_Action] {
        &self.owner_actions
    }
    pub fn clear_owner_actions(&mut self) {
        self.owner_actions.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_owner_actions(&mut self) -> &mut ::protobuf::RepeatedField<CEconItem_Action> {
        &mut self.owner_actions
    }

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

    // repeated string fraudwarnings = 13;


    pub fn get_fraudwarnings(&self) -> &[::std::string::String] {
        &self.fraudwarnings
    }
    pub fn clear_fraudwarnings(&mut self) {
        self.fraudwarnings.clear();
    }

    // Param is passed by value, moved
    pub fn set_fraudwarnings(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.fraudwarnings = v;
    }

    // Mutable pointer to the field.
    pub fn mut_fraudwarnings(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.fraudwarnings
    }

    // Take field
    pub fn take_fraudwarnings(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.fraudwarnings, ::protobuf::RepeatedField::new())
    }

    // optional string name = 14;


    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 string name_color = 15;


    pub fn get_name_color(&self) -> &str {
        match self.name_color.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_name_color(&mut self) {
        self.name_color.clear();
    }

    pub fn has_name_color(&self) -> bool {
        self.name_color.is_some()
    }

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

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

    // optional string type = 16;


    pub fn get_field_type(&self) -> &str {
        match self.field_type.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_field_type(&mut self) {
        self.field_type.clear();
    }

    pub fn has_field_type(&self) -> bool {
        self.field_type.is_some()
    }

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

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

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

    // optional string market_name = 17;


    pub fn get_market_name(&self) -> &str {
        match self.market_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_market_name(&mut self) {
        self.market_name.clear();
    }

    pub fn has_market_name(&self) -> bool {
        self.market_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_market_name(&mut self, v: ::std::string::String) {
        self.market_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_market_name(&mut self) -> &mut ::std::string::String {
        if self.market_name.is_none() {
            self.market_name.set_default();
        }
        self.market_name.as_mut().unwrap()
    }

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

    // optional string market_hash_name = 18;


    pub fn get_market_hash_name(&self) -> &str {
        match self.market_hash_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_market_hash_name(&mut self) {
        self.market_hash_name.clear();
    }

    pub fn has_market_hash_name(&self) -> bool {
        self.market_hash_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_market_hash_name(&mut self, v: ::std::string::String) {
        self.market_hash_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_market_hash_name(&mut self) -> &mut ::std::string::String {
        if self.market_hash_name.is_none() {
            self.market_hash_name.set_default();
        }
        self.market_hash_name.as_mut().unwrap()
    }

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

    // optional string market_fee = 19;


    pub fn get_market_fee(&self) -> &str {
        match self.market_fee.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_market_fee(&mut self) {
        self.market_fee.clear();
    }

    pub fn has_market_fee(&self) -> bool {
        self.market_fee.is_some()
    }

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

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

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

    // optional int32 market_fee_app = 28;


    pub fn get_market_fee_app(&self) -> i32 {
        self.market_fee_app.unwrap_or(0)
    }
    pub fn clear_market_fee_app(&mut self) {
        self.market_fee_app = ::std::option::Option::None;
    }

    pub fn has_market_fee_app(&self) -> bool {
        self.market_fee_app.is_some()
    }

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

    // optional .CEconItem_Description contained_item = 20;


    pub fn get_contained_item(&self) -> &CEconItem_Description {
        self.contained_item.as_ref().unwrap_or_else(|| <CEconItem_Description as ::protobuf::Message>::default_instance())
    }
    pub fn clear_contained_item(&mut self) {
        self.contained_item.clear();
    }

    pub fn has_contained_item(&self) -> bool {
        self.contained_item.is_some()
    }

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

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

    // Take field
    pub fn take_contained_item(&mut self) -> CEconItem_Description {
        self.contained_item.take().unwrap_or_else(|| CEconItem_Description::new())
    }

    // repeated .CEconItem_Action market_actions = 21;


    pub fn get_market_actions(&self) -> &[CEconItem_Action] {
        &self.market_actions
    }
    pub fn clear_market_actions(&mut self) {
        self.market_actions.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_market_actions(&mut self) -> &mut ::protobuf::RepeatedField<CEconItem_Action> {
        &mut self.market_actions
    }

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

    // optional bool commodity = 22;


    pub fn get_commodity(&self) -> bool {
        self.commodity.unwrap_or(false)
    }
    pub fn clear_commodity(&mut self) {
        self.commodity = ::std::option::Option::None;
    }

    pub fn has_commodity(&self) -> bool {
        self.commodity.is_some()
    }

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

    // optional int32 market_tradable_restriction = 23;


    pub fn get_market_tradable_restriction(&self) -> i32 {
        self.market_tradable_restriction.unwrap_or(0)
    }
    pub fn clear_market_tradable_restriction(&mut self) {
        self.market_tradable_restriction = ::std::option::Option::None;
    }

    pub fn has_market_tradable_restriction(&self) -> bool {
        self.market_tradable_restriction.is_some()
    }

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

    // optional int32 market_marketable_restriction = 24;


    pub fn get_market_marketable_restriction(&self) -> i32 {
        self.market_marketable_restriction.unwrap_or(0)
    }
    pub fn clear_market_marketable_restriction(&mut self) {
        self.market_marketable_restriction = ::std::option::Option::None;
    }

    pub fn has_market_marketable_restriction(&self) -> bool {
        self.market_marketable_restriction.is_some()
    }

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

    // optional bool marketable = 25;


    pub fn get_marketable(&self) -> bool {
        self.marketable.unwrap_or(false)
    }
    pub fn clear_marketable(&mut self) {
        self.marketable = ::std::option::Option::None;
    }

    pub fn has_marketable(&self) -> bool {
        self.marketable.is_some()
    }

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

    // repeated .CEconItem_Tag tags = 26;


    pub fn get_tags(&self) -> &[CEconItem_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<CEconItem_Tag>) {
        self.tags = v;
    }

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

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

    // optional string item_expiration = 27;


    pub fn get_item_expiration(&self) -> &str {
        match self.item_expiration.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_item_expiration(&mut self) {
        self.item_expiration.clear();
    }

    pub fn has_item_expiration(&self) -> bool {
        self.item_expiration.is_some()
    }

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

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

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

    // optional string market_buy_country_restriction = 30;


    pub fn get_market_buy_country_restriction(&self) -> &str {
        match self.market_buy_country_restriction.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_market_buy_country_restriction(&mut self) {
        self.market_buy_country_restriction.clear();
    }

    pub fn has_market_buy_country_restriction(&self) -> bool {
        self.market_buy_country_restriction.is_some()
    }

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

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

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

    // optional string market_sell_country_restriction = 31;


    pub fn get_market_sell_country_restriction(&self) -> &str {
        match self.market_sell_country_restriction.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_market_sell_country_restriction(&mut self) {
        self.market_sell_country_restriction.clear();
    }

    pub fn has_market_sell_country_restriction(&self) -> bool {
        self.market_sell_country_restriction.is_some()
    }

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

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

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

impl ::protobuf::Message for CEconItem_Description {
    fn is_initialized(&self) -> bool {
        for v in &self.descriptions {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.actions {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.owner_descriptions {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.owner_actions {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.contained_item {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.market_actions {
            if !v.is_initialized() {
                return false;
            }
        };
        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 => {
                    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.appid = ::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_uint64()?;
                    self.classid = ::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_uint64()?;
                    self.instanceid = ::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.currency = ::std::option::Option::Some(tmp);
                },
                5 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.background_color)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.icon_url)?;
                },
                7 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.icon_url_large)?;
                },
                8 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.descriptions)?;
                },
                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.tradable = ::std::option::Option::Some(tmp);
                },
                10 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.actions)?;
                },
                11 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.owner_descriptions)?;
                },
                12 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.owner_actions)?;
                },
                13 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.fraudwarnings)?;
                },
                14 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                },
                15 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name_color)?;
                },
                16 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.field_type)?;
                },
                17 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.market_name)?;
                },
                18 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.market_hash_name)?;
                },
                19 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.market_fee)?;
                },
                28 => {
                    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.market_fee_app = ::std::option::Option::Some(tmp);
                },
                20 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.contained_item)?;
                },
                21 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.market_actions)?;
                },
                22 => {
                    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.commodity = ::std::option::Option::Some(tmp);
                },
                23 => {
                    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.market_tradable_restriction = ::std::option::Option::Some(tmp);
                },
                24 => {
                    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.market_marketable_restriction = ::std::option::Option::Some(tmp);
                },
                25 => {
                    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.marketable = ::std::option::Option::Some(tmp);
                },
                26 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.tags)?;
                },
                27 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.item_expiration)?;
                },
                30 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.market_buy_country_restriction)?;
                },
                31 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.market_sell_country_restriction)?;
                },
                _ => {
                    ::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.appid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.classid {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.instanceid {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.currency {
            my_size += 2;
        }
        if let Some(ref v) = self.background_color.as_ref() {
            my_size += ::protobuf::rt::string_size(5, &v);
        }
        if let Some(ref v) = self.icon_url.as_ref() {
            my_size += ::protobuf::rt::string_size(6, &v);
        }
        if let Some(ref v) = self.icon_url_large.as_ref() {
            my_size += ::protobuf::rt::string_size(7, &v);
        }
        for value in &self.descriptions {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(v) = self.tradable {
            my_size += 2;
        }
        for value in &self.actions {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in &self.owner_descriptions {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in &self.owner_actions {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in &self.fraudwarnings {
            my_size += ::protobuf::rt::string_size(13, &value);
        };
        if let Some(ref v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(14, &v);
        }
        if let Some(ref v) = self.name_color.as_ref() {
            my_size += ::protobuf::rt::string_size(15, &v);
        }
        if let Some(ref v) = self.field_type.as_ref() {
            my_size += ::protobuf::rt::string_size(16, &v);
        }
        if let Some(ref v) = self.market_name.as_ref() {
            my_size += ::protobuf::rt::string_size(17, &v);
        }
        if let Some(ref v) = self.market_hash_name.as_ref() {
            my_size += ::protobuf::rt::string_size(18, &v);
        }
        if let Some(ref v) = self.market_fee.as_ref() {
            my_size += ::protobuf::rt::string_size(19, &v);
        }
        if let Some(v) = self.market_fee_app {
            my_size += ::protobuf::rt::value_size(28, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.contained_item.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.market_actions {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(v) = self.commodity {
            my_size += 3;
        }
        if let Some(v) = self.market_tradable_restriction {
            my_size += ::protobuf::rt::value_size(23, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.market_marketable_restriction {
            my_size += ::protobuf::rt::value_size(24, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.marketable {
            my_size += 3;
        }
        for value in &self.tags {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(ref v) = self.item_expiration.as_ref() {
            my_size += ::protobuf::rt::string_size(27, &v);
        }
        if let Some(ref v) = self.market_buy_country_restriction.as_ref() {
            my_size += ::protobuf::rt::string_size(30, &v);
        }
        if let Some(ref v) = self.market_sell_country_restriction.as_ref() {
            my_size += ::protobuf::rt::string_size(31, &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.appid {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.classid {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.instanceid {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.currency {
            os.write_bool(4, v)?;
        }
        if let Some(ref v) = self.background_color.as_ref() {
            os.write_string(5, &v)?;
        }
        if let Some(ref v) = self.icon_url.as_ref() {
            os.write_string(6, &v)?;
        }
        if let Some(ref v) = self.icon_url_large.as_ref() {
            os.write_string(7, &v)?;
        }
        for v in &self.descriptions {
            os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(v) = self.tradable {
            os.write_bool(9, v)?;
        }
        for v in &self.actions {
            os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        for v in &self.owner_descriptions {
            os.write_tag(11, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        for v in &self.owner_actions {
            os.write_tag(12, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        for v in &self.fraudwarnings {
            os.write_string(13, &v)?;
        };
        if let Some(ref v) = self.name.as_ref() {
            os.write_string(14, &v)?;
        }
        if let Some(ref v) = self.name_color.as_ref() {
            os.write_string(15, &v)?;
        }
        if let Some(ref v) = self.field_type.as_ref() {
            os.write_string(16, &v)?;
        }
        if let Some(ref v) = self.market_name.as_ref() {
            os.write_string(17, &v)?;
        }
        if let Some(ref v) = self.market_hash_name.as_ref() {
            os.write_string(18, &v)?;
        }
        if let Some(ref v) = self.market_fee.as_ref() {
            os.write_string(19, &v)?;
        }
        if let Some(v) = self.market_fee_app {
            os.write_int32(28, v)?;
        }
        if let Some(ref v) = self.contained_item.as_ref() {
            os.write_tag(20, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        for v in &self.market_actions {
            os.write_tag(21, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(v) = self.commodity {
            os.write_bool(22, v)?;
        }
        if let Some(v) = self.market_tradable_restriction {
            os.write_int32(23, v)?;
        }
        if let Some(v) = self.market_marketable_restriction {
            os.write_int32(24, v)?;
        }
        if let Some(v) = self.marketable {
            os.write_bool(25, v)?;
        }
        for v in &self.tags {
            os.write_tag(26, ::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.item_expiration.as_ref() {
            os.write_string(27, &v)?;
        }
        if let Some(ref v) = self.market_buy_country_restriction.as_ref() {
            os.write_string(30, &v)?;
        }
        if let Some(ref v) = self.market_sell_country_restriction.as_ref() {
            os.write_string(31, &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() -> CEconItem_Description {
        CEconItem_Description::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::ProtobufTypeInt32>(
                "appid",
                |m: &CEconItem_Description| { &m.appid },
                |m: &mut CEconItem_Description| { &mut m.appid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "classid",
                |m: &CEconItem_Description| { &m.classid },
                |m: &mut CEconItem_Description| { &mut m.classid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "instanceid",
                |m: &CEconItem_Description| { &m.instanceid },
                |m: &mut CEconItem_Description| { &mut m.instanceid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "currency",
                |m: &CEconItem_Description| { &m.currency },
                |m: &mut CEconItem_Description| { &mut m.currency },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "background_color",
                |m: &CEconItem_Description| { &m.background_color },
                |m: &mut CEconItem_Description| { &mut m.background_color },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "icon_url",
                |m: &CEconItem_Description| { &m.icon_url },
                |m: &mut CEconItem_Description| { &mut m.icon_url },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "icon_url_large",
                |m: &CEconItem_Description| { &m.icon_url_large },
                |m: &mut CEconItem_Description| { &mut m.icon_url_large },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CEconItem_DescriptionLine>>(
                "descriptions",
                |m: &CEconItem_Description| { &m.descriptions },
                |m: &mut CEconItem_Description| { &mut m.descriptions },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "tradable",
                |m: &CEconItem_Description| { &m.tradable },
                |m: &mut CEconItem_Description| { &mut m.tradable },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CEconItem_Action>>(
                "actions",
                |m: &CEconItem_Description| { &m.actions },
                |m: &mut CEconItem_Description| { &mut m.actions },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CEconItem_DescriptionLine>>(
                "owner_descriptions",
                |m: &CEconItem_Description| { &m.owner_descriptions },
                |m: &mut CEconItem_Description| { &mut m.owner_descriptions },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CEconItem_Action>>(
                "owner_actions",
                |m: &CEconItem_Description| { &m.owner_actions },
                |m: &mut CEconItem_Description| { &mut m.owner_actions },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "fraudwarnings",
                |m: &CEconItem_Description| { &m.fraudwarnings },
                |m: &mut CEconItem_Description| { &mut m.fraudwarnings },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &CEconItem_Description| { &m.name },
                |m: &mut CEconItem_Description| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name_color",
                |m: &CEconItem_Description| { &m.name_color },
                |m: &mut CEconItem_Description| { &mut m.name_color },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "type",
                |m: &CEconItem_Description| { &m.field_type },
                |m: &mut CEconItem_Description| { &mut m.field_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "market_name",
                |m: &CEconItem_Description| { &m.market_name },
                |m: &mut CEconItem_Description| { &mut m.market_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "market_hash_name",
                |m: &CEconItem_Description| { &m.market_hash_name },
                |m: &mut CEconItem_Description| { &mut m.market_hash_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "market_fee",
                |m: &CEconItem_Description| { &m.market_fee },
                |m: &mut CEconItem_Description| { &mut m.market_fee },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "market_fee_app",
                |m: &CEconItem_Description| { &m.market_fee_app },
                |m: &mut CEconItem_Description| { &mut m.market_fee_app },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CEconItem_Description>>(
                "contained_item",
                |m: &CEconItem_Description| { &m.contained_item },
                |m: &mut CEconItem_Description| { &mut m.contained_item },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CEconItem_Action>>(
                "market_actions",
                |m: &CEconItem_Description| { &m.market_actions },
                |m: &mut CEconItem_Description| { &mut m.market_actions },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "commodity",
                |m: &CEconItem_Description| { &m.commodity },
                |m: &mut CEconItem_Description| { &mut m.commodity },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "market_tradable_restriction",
                |m: &CEconItem_Description| { &m.market_tradable_restriction },
                |m: &mut CEconItem_Description| { &mut m.market_tradable_restriction },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "market_marketable_restriction",
                |m: &CEconItem_Description| { &m.market_marketable_restriction },
                |m: &mut CEconItem_Description| { &mut m.market_marketable_restriction },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "marketable",
                |m: &CEconItem_Description| { &m.marketable },
                |m: &mut CEconItem_Description| { &mut m.marketable },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CEconItem_Tag>>(
                "tags",
                |m: &CEconItem_Description| { &m.tags },
                |m: &mut CEconItem_Description| { &mut m.tags },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "item_expiration",
                |m: &CEconItem_Description| { &m.item_expiration },
                |m: &mut CEconItem_Description| { &mut m.item_expiration },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "market_buy_country_restriction",
                |m: &CEconItem_Description| { &m.market_buy_country_restriction },
                |m: &mut CEconItem_Description| { &mut m.market_buy_country_restriction },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "market_sell_country_restriction",
                |m: &CEconItem_Description| { &m.market_sell_country_restriction },
                |m: &mut CEconItem_Description| { &mut m.market_sell_country_restriction },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CEconItem_Description>(
                "CEconItem_Description",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CEconItem_Description {
    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.classid = ::std::option::Option::None;
        self.instanceid = ::std::option::Option::None;
        self.currency = ::std::option::Option::None;
        self.background_color.clear();
        self.icon_url.clear();
        self.icon_url_large.clear();
        self.descriptions.clear();
        self.tradable = ::std::option::Option::None;
        self.actions.clear();
        self.owner_descriptions.clear();
        self.owner_actions.clear();
        self.fraudwarnings.clear();
        self.name.clear();
        self.name_color.clear();
        self.field_type.clear();
        self.market_name.clear();
        self.market_hash_name.clear();
        self.market_fee.clear();
        self.market_fee_app = ::std::option::Option::None;
        self.contained_item.clear();
        self.market_actions.clear();
        self.commodity = ::std::option::Option::None;
        self.market_tradable_restriction = ::std::option::Option::None;
        self.market_marketable_restriction = ::std::option::Option::None;
        self.marketable = ::std::option::Option::None;
        self.tags.clear();
        self.item_expiration.clear();
        self.market_buy_country_restriction.clear();
        self.market_sell_country_restriction.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CEconItem_Tag {
    // message fields
    appid: ::std::option::Option<u32>,
    category: ::protobuf::SingularField<::std::string::String>,
    internal_name: ::protobuf::SingularField<::std::string::String>,
    localized_category_name: ::protobuf::SingularField<::std::string::String>,
    localized_tag_name: ::protobuf::SingularField<::std::string::String>,
    color: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 appid = 1;


    pub fn get_appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }
    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

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

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

    // optional string category = 2;


    pub fn get_category(&self) -> &str {
        match self.category.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_category(&mut self) {
        self.category.clear();
    }

    pub fn has_category(&self) -> bool {
        self.category.is_some()
    }

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

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

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

    // optional string internal_name = 3;


    pub fn get_internal_name(&self) -> &str {
        match self.internal_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_internal_name(&mut self) {
        self.internal_name.clear();
    }

    pub fn has_internal_name(&self) -> bool {
        self.internal_name.is_some()
    }

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

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

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

    // optional string localized_category_name = 4;


    pub fn get_localized_category_name(&self) -> &str {
        match self.localized_category_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_localized_category_name(&mut self) {
        self.localized_category_name.clear();
    }

    pub fn has_localized_category_name(&self) -> bool {
        self.localized_category_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_localized_category_name(&mut self, v: ::std::string::String) {
        self.localized_category_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_localized_category_name(&mut self) -> &mut ::std::string::String {
        if self.localized_category_name.is_none() {
            self.localized_category_name.set_default();
        }
        self.localized_category_name.as_mut().unwrap()
    }

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

    // optional string localized_tag_name = 5;


    pub fn get_localized_tag_name(&self) -> &str {
        match self.localized_tag_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_localized_tag_name(&mut self) {
        self.localized_tag_name.clear();
    }

    pub fn has_localized_tag_name(&self) -> bool {
        self.localized_tag_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_localized_tag_name(&mut self, v: ::std::string::String) {
        self.localized_tag_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_localized_tag_name(&mut self) -> &mut ::std::string::String {
        if self.localized_tag_name.is_none() {
            self.localized_tag_name.set_default();
        }
        self.localized_tag_name.as_mut().unwrap()
    }

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

    // optional string color = 6;


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

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

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

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

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

impl ::protobuf::Message for CEconItem_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.appid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.category)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.internal_name)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.localized_category_name)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.localized_tag_name)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.color)?;
                },
                _ => {
                    ::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.appid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.category.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(ref v) = self.internal_name.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(ref v) = self.localized_category_name.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        if let Some(ref v) = self.localized_tag_name.as_ref() {
            my_size += ::protobuf::rt::string_size(5, &v);
        }
        if let Some(ref v) = self.color.as_ref() {
            my_size += ::protobuf::rt::string_size(6, &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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(ref v) = self.category.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(ref v) = self.internal_name.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(ref v) = self.localized_category_name.as_ref() {
            os.write_string(4, &v)?;
        }
        if let Some(ref v) = self.localized_tag_name.as_ref() {
            os.write_string(5, &v)?;
        }
        if let Some(ref v) = self.color.as_ref() {
            os.write_string(6, &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() -> CEconItem_Tag {
        CEconItem_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>(
                "appid",
                |m: &CEconItem_Tag| { &m.appid },
                |m: &mut CEconItem_Tag| { &mut m.appid },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "category",
                |m: &CEconItem_Tag| { &m.category },
                |m: &mut CEconItem_Tag| { &mut m.category },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "internal_name",
                |m: &CEconItem_Tag| { &m.internal_name },
                |m: &mut CEconItem_Tag| { &mut m.internal_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "localized_category_name",
                |m: &CEconItem_Tag| { &m.localized_category_name },
                |m: &mut CEconItem_Tag| { &mut m.localized_category_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "localized_tag_name",
                |m: &CEconItem_Tag| { &m.localized_tag_name },
                |m: &mut CEconItem_Tag| { &mut m.localized_tag_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "color",
                |m: &CEconItem_Tag| { &m.color },
                |m: &mut CEconItem_Tag| { &mut m.color },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CEconItem_Tag>(
                "CEconItem_Tag",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CEconItem_Tag {
    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.category.clear();
        self.internal_name.clear();
        self.localized_category_name.clear();
        self.localized_tag_name.clear();
        self.color.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // repeated .CEconItem_Description descriptions = 1;


    pub fn get_descriptions(&self) -> &[CEconItem_Description] {
        &self.descriptions
    }
    pub fn clear_descriptions(&mut self) {
        self.descriptions.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_descriptions(&mut self) -> &mut ::protobuf::RepeatedField<CEconItem_Description> {
        &mut self.descriptions
    }

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

impl ::protobuf::Message for CEcon_GetAssetClassInfo_Response {
    fn is_initialized(&self) -> bool {
        for v in &self.descriptions {
            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.descriptions)?;
                },
                _ => {
                    ::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.descriptions {
            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.descriptions {
            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() -> CEcon_GetAssetClassInfo_Response {
        CEcon_GetAssetClassInfo_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<CEconItem_Description>>(
                "descriptions",
                |m: &CEcon_GetAssetClassInfo_Response| { &m.descriptions },
                |m: &mut CEcon_GetAssetClassInfo_Response| { &mut m.descriptions },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CEcon_GetAssetClassInfo_Response>(
                "CEcon_GetAssetClassInfo_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n$steammessages_econ.steamclient.proto\x1a,steammessages_unified_base.s\
    teamclient.proto\"V\n&CEcon_GetTradeOfferAccessToken_Request\x12,\n\x12g\
    enerate_new_token\x18\x01\x20\x01(\x08R\x10generateNewToken\"b\n'CEcon_G\
    etTradeOfferAccessToken_Response\x127\n\x18trade_offer_access_token\x18\
    \x01\x20\x01(\tR\x15tradeOfferAccessToken\"N\n-CEcon_ClientGetItemShopOv\
    erlayAuthURL_Request\x12\x1d\n\nreturn_url\x18\x01\x20\x01(\tR\treturnUr\
    l\"B\n.CEcon_ClientGetItemShopOverlayAuthURL_Response\x12\x10\n\x03url\
    \x18\x01\x20\x01(\tR\x03url\"\xd8\x01\n\x1fCEcon_GetAssetClassInfo_Reque\
    st\x12\x1a\n\x08language\x18\x01\x20\x01(\tR\x08language\x12\x14\n\x05ap\
    pid\x18\x02\x20\x01(\rR\x05appid\x12@\n\x07classes\x18\x03\x20\x03(\x0b2\
    &.CEcon_GetAssetClassInfo_Request.ClassR\x07classes\x1aA\n\x05Class\x12\
    \x18\n\x07classid\x18\x01\x20\x01(\x04R\x07classid\x12\x1e\n\ninstanceid\
    \x18\x02\x20\x01(\x04R\ninstanceid\"q\n\x19CEconItem_DescriptionLine\x12\
    \x12\n\x04type\x18\x01\x20\x01(\tR\x04type\x12\x14\n\x05value\x18\x02\
    \x20\x01(\tR\x05value\x12\x14\n\x05color\x18\x03\x20\x01(\tR\x05color\
    \x12\x14\n\x05label\x18\x04\x20\x01(\tR\x05label\":\n\x10CEconItem_Actio\
    n\x12\x12\n\x04link\x18\x01\x20\x01(\tR\x04link\x12\x12\n\x04name\x18\
    \x02\x20\x01(\tR\x04name\"\x8c\n\n\x15CEconItem_Description\x12\x14\n\
    \x05appid\x18\x01\x20\x01(\x05R\x05appid\x12\x18\n\x07classid\x18\x02\
    \x20\x01(\x04R\x07classid\x12\x1e\n\ninstanceid\x18\x03\x20\x01(\x04R\ni\
    nstanceid\x12\x1a\n\x08currency\x18\x04\x20\x01(\x08R\x08currency\x12)\n\
    \x10background_color\x18\x05\x20\x01(\tR\x0fbackgroundColor\x12\x19\n\
    \x08icon_url\x18\x06\x20\x01(\tR\x07iconUrl\x12$\n\x0eicon_url_large\x18\
    \x07\x20\x01(\tR\x0ciconUrlLarge\x12>\n\x0cdescriptions\x18\x08\x20\x03(\
    \x0b2\x1a.CEconItem_DescriptionLineR\x0cdescriptions\x12\x1a\n\x08tradab\
    le\x18\t\x20\x01(\x08R\x08tradable\x12+\n\x07actions\x18\n\x20\x03(\x0b2\
    \x11.CEconItem_ActionR\x07actions\x12I\n\x12owner_descriptions\x18\x0b\
    \x20\x03(\x0b2\x1a.CEconItem_DescriptionLineR\x11ownerDescriptions\x126\
    \n\rowner_actions\x18\x0c\x20\x03(\x0b2\x11.CEconItem_ActionR\x0cownerAc\
    tions\x12$\n\rfraudwarnings\x18\r\x20\x03(\tR\rfraudwarnings\x12\x12\n\
    \x04name\x18\x0e\x20\x01(\tR\x04name\x12\x1d\n\nname_color\x18\x0f\x20\
    \x01(\tR\tnameColor\x12\x12\n\x04type\x18\x10\x20\x01(\tR\x04type\x12\
    \x1f\n\x0bmarket_name\x18\x11\x20\x01(\tR\nmarketName\x12(\n\x10market_h\
    ash_name\x18\x12\x20\x01(\tR\x0emarketHashName\x12\x1d\n\nmarket_fee\x18\
    \x13\x20\x01(\tR\tmarketFee\x12$\n\x0emarket_fee_app\x18\x1c\x20\x01(\
    \x05R\x0cmarketFeeApp\x12=\n\x0econtained_item\x18\x14\x20\x01(\x0b2\x16\
    .CEconItem_DescriptionR\rcontainedItem\x128\n\x0emarket_actions\x18\x15\
    \x20\x03(\x0b2\x11.CEconItem_ActionR\rmarketActions\x12\x1c\n\tcommodity\
    \x18\x16\x20\x01(\x08R\tcommodity\x12>\n\x1bmarket_tradable_restriction\
    \x18\x17\x20\x01(\x05R\x19marketTradableRestriction\x12B\n\x1dmarket_mar\
    ketable_restriction\x18\x18\x20\x01(\x05R\x1bmarketMarketableRestriction\
    \x12\x1e\n\nmarketable\x18\x19\x20\x01(\x08R\nmarketable\x12\"\n\x04tags\
    \x18\x1a\x20\x03(\x0b2\x0e.CEconItem_TagR\x04tags\x12'\n\x0fitem_expirat\
    ion\x18\x1b\x20\x01(\tR\x0eitemExpiration\x12C\n\x1emarket_buy_country_r\
    estriction\x18\x1e\x20\x01(\tR\x1bmarketBuyCountryRestriction\x12E\n\x1f\
    market_sell_country_restriction\x18\x1f\x20\x01(\tR\x1cmarketSellCountry\
    Restriction\"\xe7\x03\n\rCEconItem_Tag\x128\n\x05appid\x18\x01\x20\x01(\
    \rR\x05appidB\"\x82\xb5\x18\x1eThe\x20app\x20that\x20contains\x20the\x20\
    item\x12T\n\x08category\x18\x02\x20\x01(\tR\x08categoryB8\x82\xb5\x184Th\
    e\x20internal\x20name\x20of\x20the\x20category\x20the\x20tag\x20belongs\
    \x20to\x12E\n\rinternal_name\x18\x03\x20\x01(\tR\x0cinternalNameB\x20\
    \x82\xb5\x18\x1cThe\x20internal\x20name\x20of\x20the\x20tag\x12^\n\x17lo\
    calized_category_name\x18\x04\x20\x01(\tR\x15localizedCategoryNameB&\x82\
    \xb5\x18\"The\x20localized\x20name\x20of\x20the\x20category\x12O\n\x12lo\
    calized_tag_name\x18\x05\x20\x01(\tR\x10localizedTagNameB!\x82\xb5\x18\
    \x1dThe\x20localized\x20name\x20of\x20the\x20tag\x12N\n\x05color\x18\x06\
    \x20\x01(\tR\x05colorB8\x82\xb5\x184The\x20color\x20to\x20use\x20when\
    \x20displaying\x20the\x20tag\x20to\x20the\x20user\"^\n\x20CEcon_GetAsset\
    ClassInfo_Response\x12:\n\x0cdescriptions\x18\x01\x20\x03(\x0b2\x16.CEco\
    nItem_DescriptionR\x0cdescriptions2\xe2\x04\n\x04Econ\x12\x9a\x01\n\x18G\
    etTradeOfferAccessToken\x12'.CEcon_GetTradeOfferAccessToken_Request\x1a(\
    .CEcon_GetTradeOfferAccessToken_Response\"+\x82\xb5\x18'Get\x20the\x20us\
    er's\x20trade\x20offer\x20access\x20token\x12\xd9\x01\n\x1fClientGetItem\
    ShopOverlayAuthURL\x12..CEcon_ClientGetItemShopOverlayAuthURL_Request\
    \x1a/.CEcon_ClientGetItemShopOverlayAuthURL_Response\"U\x82\xb5\x18QGene\
    rates\x20a\x20URL\x20which\x20sets\x20a\x20secure\x20cookie\x20for\x20in\
    -game-browser\x20itemshop\x20purchases\x12\x9f\x01\n\x11GetAssetClassInf\
    o\x12\x20.CEcon_GetAssetClassInfo_Request\x1a!.CEcon_GetAssetClassInfo_R\
    esponse\"E\x82\xb5\x18AReturns\x20description\x20information\x20about\
    \x20the\x20passed\x20in\x20asset\x20classes\x1a?\x82\xb5\x18;A\x20servic\
    e\x20that\x20provides\x20communication\x20with\x20the\x20econ\x20servers\
    B\x03\x80\x01\x01J\xc2\"\n\x06\x12\x04\0\0g\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\x04\0\x12\x04\x04\0\x06\x01\n\n\n\x03\x04\0\x01\x12\x03\x04\
    \x08.\n\x0b\n\x04\x04\0\x02\0\x12\x03\x05\x08-\n\x0c\n\x05\x04\0\x02\0\
    \x04\x12\x03\x05\x08\x10\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x05\x11\x15\
    \n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x05\x16(\n\x0c\n\x05\x04\0\x02\0\
    \x03\x12\x03\x05+,\n\n\n\x02\x04\x01\x12\x04\x08\0\n\x01\n\n\n\x03\x04\
    \x01\x01\x12\x03\x08\x08/\n\x0b\n\x04\x04\x01\x02\0\x12\x03\t\x085\n\x0c\
    \n\x05\x04\x01\x02\0\x04\x12\x03\t\x08\x10\n\x0c\n\x05\x04\x01\x02\0\x05\
    \x12\x03\t\x11\x17\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\t\x180\n\x0c\n\
    \x05\x04\x01\x02\0\x03\x12\x03\t34\n\n\n\x02\x04\x02\x12\x04\x0c\0\x0e\
    \x01\n\n\n\x03\x04\x02\x01\x12\x03\x0c\x085\n\x0b\n\x04\x04\x02\x02\0\
    \x12\x03\r\x08'\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03\r\x08\x10\n\x0c\n\
    \x05\x04\x02\x02\0\x05\x12\x03\r\x11\x17\n\x0c\n\x05\x04\x02\x02\0\x01\
    \x12\x03\r\x18\"\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03\r%&\n\n\n\x02\x04\
    \x03\x12\x04\x10\0\x12\x01\n\n\n\x03\x04\x03\x01\x12\x03\x10\x086\n\x0b\
    \n\x04\x04\x03\x02\0\x12\x03\x11\x08\x20\n\x0c\n\x05\x04\x03\x02\0\x04\
    \x12\x03\x11\x08\x10\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x03\x11\x11\x17\n\
    \x0c\n\x05\x04\x03\x02\0\x01\x12\x03\x11\x18\x1b\n\x0c\n\x05\x04\x03\x02\
    \0\x03\x12\x03\x11\x1e\x1f\n\n\n\x02\x04\x04\x12\x04\x14\0\x1d\x01\n\n\n\
    \x03\x04\x04\x01\x12\x03\x14\x08'\n\x0c\n\x04\x04\x04\x03\0\x12\x04\x15\
    \x08\x18\t\n\x0c\n\x05\x04\x04\x03\0\x01\x12\x03\x15\x10\x15\n\r\n\x06\
    \x04\x04\x03\0\x02\0\x12\x03\x16\x10,\n\x0e\n\x07\x04\x04\x03\0\x02\0\
    \x04\x12\x03\x16\x10\x18\n\x0e\n\x07\x04\x04\x03\0\x02\0\x05\x12\x03\x16\
    \x19\x1f\n\x0e\n\x07\x04\x04\x03\0\x02\0\x01\x12\x03\x16\x20'\n\x0e\n\
    \x07\x04\x04\x03\0\x02\0\x03\x12\x03\x16*+\n\r\n\x06\x04\x04\x03\0\x02\
    \x01\x12\x03\x17\x10/\n\x0e\n\x07\x04\x04\x03\0\x02\x01\x04\x12\x03\x17\
    \x10\x18\n\x0e\n\x07\x04\x04\x03\0\x02\x01\x05\x12\x03\x17\x19\x1f\n\x0e\
    \n\x07\x04\x04\x03\0\x02\x01\x01\x12\x03\x17\x20*\n\x0e\n\x07\x04\x04\
    \x03\0\x02\x01\x03\x12\x03\x17-.\n\x0b\n\x04\x04\x04\x02\0\x12\x03\x1a\
    \x08%\n\x0c\n\x05\x04\x04\x02\0\x04\x12\x03\x1a\x08\x10\n\x0c\n\x05\x04\
    \x04\x02\0\x05\x12\x03\x1a\x11\x17\n\x0c\n\x05\x04\x04\x02\0\x01\x12\x03\
    \x1a\x18\x20\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03\x1a#$\n\x0b\n\x04\x04\
    \x04\x02\x01\x12\x03\x1b\x08\"\n\x0c\n\x05\x04\x04\x02\x01\x04\x12\x03\
    \x1b\x08\x10\n\x0c\n\x05\x04\x04\x02\x01\x05\x12\x03\x1b\x11\x17\n\x0c\n\
    \x05\x04\x04\x02\x01\x01\x12\x03\x1b\x18\x1d\n\x0c\n\x05\x04\x04\x02\x01\
    \x03\x12\x03\x1b\x20!\n\x0b\n\x04\x04\x04\x02\x02\x12\x03\x1c\x08D\n\x0c\
    \n\x05\x04\x04\x02\x02\x04\x12\x03\x1c\x08\x10\n\x0c\n\x05\x04\x04\x02\
    \x02\x06\x12\x03\x1c\x117\n\x0c\n\x05\x04\x04\x02\x02\x01\x12\x03\x1c8?\
    \n\x0c\n\x05\x04\x04\x02\x02\x03\x12\x03\x1cBC\n\n\n\x02\x04\x05\x12\x04\
    \x1f\0$\x01\n\n\n\x03\x04\x05\x01\x12\x03\x1f\x08!\n\x0b\n\x04\x04\x05\
    \x02\0\x12\x03\x20\x08!\n\x0c\n\x05\x04\x05\x02\0\x04\x12\x03\x20\x08\
    \x10\n\x0c\n\x05\x04\x05\x02\0\x05\x12\x03\x20\x11\x17\n\x0c\n\x05\x04\
    \x05\x02\0\x01\x12\x03\x20\x18\x1c\n\x0c\n\x05\x04\x05\x02\0\x03\x12\x03\
    \x20\x1f\x20\n\x0b\n\x04\x04\x05\x02\x01\x12\x03!\x08\"\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\x1d\n\x0c\n\
    \x05\x04\x05\x02\x01\x03\x12\x03!\x20!\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\x17\n\x0c\n\x05\x04\x05\x02\x02\
    \x01\x12\x03\"\x18\x1d\n\x0c\n\x05\x04\x05\x02\x02\x03\x12\x03\"\x20!\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\x17\n\
    \x0c\n\x05\x04\x05\x02\x03\x01\x12\x03#\x18\x1d\n\x0c\n\x05\x04\x05\x02\
    \x03\x03\x12\x03#\x20!\n\n\n\x02\x04\x06\x12\x04&\0)\x01\n\n\n\x03\x04\
    \x06\x01\x12\x03&\x08\x18\n\x0b\n\x04\x04\x06\x02\0\x12\x03'\x08!\n\x0c\
    \n\x05\x04\x06\x02\0\x04\x12\x03'\x08\x10\n\x0c\n\x05\x04\x06\x02\0\x05\
    \x12\x03'\x11\x17\n\x0c\n\x05\x04\x06\x02\0\x01\x12\x03'\x18\x1c\n\x0c\n\
    \x05\x04\x06\x02\0\x03\x12\x03'\x1f\x20\n\x0b\n\x04\x04\x06\x02\x01\x12\
    \x03(\x08!\n\x0c\n\x05\x04\x06\x02\x01\x04\x12\x03(\x08\x10\n\x0c\n\x05\
    \x04\x06\x02\x01\x05\x12\x03(\x11\x17\n\x0c\n\x05\x04\x06\x02\x01\x01\
    \x12\x03(\x18\x1c\n\x0c\n\x05\x04\x06\x02\x01\x03\x12\x03(\x1f\x20\n\n\n\
    \x02\x04\x07\x12\x04+\0J\x01\n\n\n\x03\x04\x07\x01\x12\x03+\x08\x1d\n\
    \x0b\n\x04\x04\x07\x02\0\x12\x03,\x08!\n\x0c\n\x05\x04\x07\x02\0\x04\x12\
    \x03,\x08\x10\n\x0c\n\x05\x04\x07\x02\0\x05\x12\x03,\x11\x16\n\x0c\n\x05\
    \x04\x07\x02\0\x01\x12\x03,\x17\x1c\n\x0c\n\x05\x04\x07\x02\0\x03\x12\
    \x03,\x1f\x20\n\x0b\n\x04\x04\x07\x02\x01\x12\x03-\x08$\n\x0c\n\x05\x04\
    \x07\x02\x01\x04\x12\x03-\x08\x10\n\x0c\n\x05\x04\x07\x02\x01\x05\x12\
    \x03-\x11\x17\n\x0c\n\x05\x04\x07\x02\x01\x01\x12\x03-\x18\x1f\n\x0c\n\
    \x05\x04\x07\x02\x01\x03\x12\x03-\"#\n\x0b\n\x04\x04\x07\x02\x02\x12\x03\
    .\x08'\n\x0c\n\x05\x04\x07\x02\x02\x04\x12\x03.\x08\x10\n\x0c\n\x05\x04\
    \x07\x02\x02\x05\x12\x03.\x11\x17\n\x0c\n\x05\x04\x07\x02\x02\x01\x12\
    \x03.\x18\"\n\x0c\n\x05\x04\x07\x02\x02\x03\x12\x03.%&\n\x0b\n\x04\x04\
    \x07\x02\x03\x12\x03/\x08#\n\x0c\n\x05\x04\x07\x02\x03\x04\x12\x03/\x08\
    \x10\n\x0c\n\x05\x04\x07\x02\x03\x05\x12\x03/\x11\x15\n\x0c\n\x05\x04\
    \x07\x02\x03\x01\x12\x03/\x16\x1e\n\x0c\n\x05\x04\x07\x02\x03\x03\x12\
    \x03/!\"\n\x0b\n\x04\x04\x07\x02\x04\x12\x030\x08-\n\x0c\n\x05\x04\x07\
    \x02\x04\x04\x12\x030\x08\x10\n\x0c\n\x05\x04\x07\x02\x04\x05\x12\x030\
    \x11\x17\n\x0c\n\x05\x04\x07\x02\x04\x01\x12\x030\x18(\n\x0c\n\x05\x04\
    \x07\x02\x04\x03\x12\x030+,\n\x0b\n\x04\x04\x07\x02\x05\x12\x031\x08%\n\
    \x0c\n\x05\x04\x07\x02\x05\x04\x12\x031\x08\x10\n\x0c\n\x05\x04\x07\x02\
    \x05\x05\x12\x031\x11\x17\n\x0c\n\x05\x04\x07\x02\x05\x01\x12\x031\x18\
    \x20\n\x0c\n\x05\x04\x07\x02\x05\x03\x12\x031#$\n\x0b\n\x04\x04\x07\x02\
    \x06\x12\x032\x08+\n\x0c\n\x05\x04\x07\x02\x06\x04\x12\x032\x08\x10\n\
    \x0c\n\x05\x04\x07\x02\x06\x05\x12\x032\x11\x17\n\x0c\n\x05\x04\x07\x02\
    \x06\x01\x12\x032\x18&\n\x0c\n\x05\x04\x07\x02\x06\x03\x12\x032)*\n\x0b\
    \n\x04\x04\x07\x02\x07\x12\x033\x08=\n\x0c\n\x05\x04\x07\x02\x07\x04\x12\
    \x033\x08\x10\n\x0c\n\x05\x04\x07\x02\x07\x06\x12\x033\x11+\n\x0c\n\x05\
    \x04\x07\x02\x07\x01\x12\x033,8\n\x0c\n\x05\x04\x07\x02\x07\x03\x12\x033\
    ;<\n\x0b\n\x04\x04\x07\x02\x08\x12\x034\x08#\n\x0c\n\x05\x04\x07\x02\x08\
    \x04\x12\x034\x08\x10\n\x0c\n\x05\x04\x07\x02\x08\x05\x12\x034\x11\x15\n\
    \x0c\n\x05\x04\x07\x02\x08\x01\x12\x034\x16\x1e\n\x0c\n\x05\x04\x07\x02\
    \x08\x03\x12\x034!\"\n\x0b\n\x04\x04\x07\x02\t\x12\x035\x080\n\x0c\n\x05\
    \x04\x07\x02\t\x04\x12\x035\x08\x10\n\x0c\n\x05\x04\x07\x02\t\x06\x12\
    \x035\x11\"\n\x0c\n\x05\x04\x07\x02\t\x01\x12\x035#*\n\x0c\n\x05\x04\x07\
    \x02\t\x03\x12\x035-/\n\x0b\n\x04\x04\x07\x02\n\x12\x036\x08D\n\x0c\n\
    \x05\x04\x07\x02\n\x04\x12\x036\x08\x10\n\x0c\n\x05\x04\x07\x02\n\x06\
    \x12\x036\x11+\n\x0c\n\x05\x04\x07\x02\n\x01\x12\x036,>\n\x0c\n\x05\x04\
    \x07\x02\n\x03\x12\x036AC\n\x0b\n\x04\x04\x07\x02\x0b\x12\x037\x086\n\
    \x0c\n\x05\x04\x07\x02\x0b\x04\x12\x037\x08\x10\n\x0c\n\x05\x04\x07\x02\
    \x0b\x06\x12\x037\x11\"\n\x0c\n\x05\x04\x07\x02\x0b\x01\x12\x037#0\n\x0c\
    \n\x05\x04\x07\x02\x0b\x03\x12\x03735\n\x0b\n\x04\x04\x07\x02\x0c\x12\
    \x038\x08+\n\x0c\n\x05\x04\x07\x02\x0c\x04\x12\x038\x08\x10\n\x0c\n\x05\
    \x04\x07\x02\x0c\x05\x12\x038\x11\x17\n\x0c\n\x05\x04\x07\x02\x0c\x01\
    \x12\x038\x18%\n\x0c\n\x05\x04\x07\x02\x0c\x03\x12\x038(*\n\x0b\n\x04\
    \x04\x07\x02\r\x12\x039\x08\"\n\x0c\n\x05\x04\x07\x02\r\x04\x12\x039\x08\
    \x10\n\x0c\n\x05\x04\x07\x02\r\x05\x12\x039\x11\x17\n\x0c\n\x05\x04\x07\
    \x02\r\x01\x12\x039\x18\x1c\n\x0c\n\x05\x04\x07\x02\r\x03\x12\x039\x1f!\
    \n\x0b\n\x04\x04\x07\x02\x0e\x12\x03:\x08(\n\x0c\n\x05\x04\x07\x02\x0e\
    \x04\x12\x03:\x08\x10\n\x0c\n\x05\x04\x07\x02\x0e\x05\x12\x03:\x11\x17\n\
    \x0c\n\x05\x04\x07\x02\x0e\x01\x12\x03:\x18\"\n\x0c\n\x05\x04\x07\x02\
    \x0e\x03\x12\x03:%'\n\x0b\n\x04\x04\x07\x02\x0f\x12\x03;\x08\"\n\x0c\n\
    \x05\x04\x07\x02\x0f\x04\x12\x03;\x08\x10\n\x0c\n\x05\x04\x07\x02\x0f\
    \x05\x12\x03;\x11\x17\n\x0c\n\x05\x04\x07\x02\x0f\x01\x12\x03;\x18\x1c\n\
    \x0c\n\x05\x04\x07\x02\x0f\x03\x12\x03;\x1f!\n\x0b\n\x04\x04\x07\x02\x10\
    \x12\x03<\x08)\n\x0c\n\x05\x04\x07\x02\x10\x04\x12\x03<\x08\x10\n\x0c\n\
    \x05\x04\x07\x02\x10\x05\x12\x03<\x11\x17\n\x0c\n\x05\x04\x07\x02\x10\
    \x01\x12\x03<\x18#\n\x0c\n\x05\x04\x07\x02\x10\x03\x12\x03<&(\n\x0b\n\
    \x04\x04\x07\x02\x11\x12\x03=\x08.\n\x0c\n\x05\x04\x07\x02\x11\x04\x12\
    \x03=\x08\x10\n\x0c\n\x05\x04\x07\x02\x11\x05\x12\x03=\x11\x17\n\x0c\n\
    \x05\x04\x07\x02\x11\x01\x12\x03=\x18(\n\x0c\n\x05\x04\x07\x02\x11\x03\
    \x12\x03=+-\n\x0b\n\x04\x04\x07\x02\x12\x12\x03>\x08(\n\x0c\n\x05\x04\
    \x07\x02\x12\x04\x12\x03>\x08\x10\n\x0c\n\x05\x04\x07\x02\x12\x05\x12\
    \x03>\x11\x17\n\x0c\n\x05\x04\x07\x02\x12\x01\x12\x03>\x18\"\n\x0c\n\x05\
    \x04\x07\x02\x12\x03\x12\x03>%'\n\x0b\n\x04\x04\x07\x02\x13\x12\x03?\x08\
    +\n\x0c\n\x05\x04\x07\x02\x13\x04\x12\x03?\x08\x10\n\x0c\n\x05\x04\x07\
    \x02\x13\x05\x12\x03?\x11\x16\n\x0c\n\x05\x04\x07\x02\x13\x01\x12\x03?\
    \x17%\n\x0c\n\x05\x04\x07\x02\x13\x03\x12\x03?(*\n\x0b\n\x04\x04\x07\x02\
    \x14\x12\x03@\x08<\n\x0c\n\x05\x04\x07\x02\x14\x04\x12\x03@\x08\x10\n\
    \x0c\n\x05\x04\x07\x02\x14\x06\x12\x03@\x11'\n\x0c\n\x05\x04\x07\x02\x14\
    \x01\x12\x03@(6\n\x0c\n\x05\x04\x07\x02\x14\x03\x12\x03@9;\n\x0b\n\x04\
    \x04\x07\x02\x15\x12\x03A\x087\n\x0c\n\x05\x04\x07\x02\x15\x04\x12\x03A\
    \x08\x10\n\x0c\n\x05\x04\x07\x02\x15\x06\x12\x03A\x11\"\n\x0c\n\x05\x04\
    \x07\x02\x15\x01\x12\x03A#1\n\x0c\n\x05\x04\x07\x02\x15\x03\x12\x03A46\n\
    \x0b\n\x04\x04\x07\x02\x16\x12\x03B\x08%\n\x0c\n\x05\x04\x07\x02\x16\x04\
    \x12\x03B\x08\x10\n\x0c\n\x05\x04\x07\x02\x16\x05\x12\x03B\x11\x15\n\x0c\
    \n\x05\x04\x07\x02\x16\x01\x12\x03B\x16\x1f\n\x0c\n\x05\x04\x07\x02\x16\
    \x03\x12\x03B\"$\n\x0b\n\x04\x04\x07\x02\x17\x12\x03C\x088\n\x0c\n\x05\
    \x04\x07\x02\x17\x04\x12\x03C\x08\x10\n\x0c\n\x05\x04\x07\x02\x17\x05\
    \x12\x03C\x11\x16\n\x0c\n\x05\x04\x07\x02\x17\x01\x12\x03C\x172\n\x0c\n\
    \x05\x04\x07\x02\x17\x03\x12\x03C57\n\x0b\n\x04\x04\x07\x02\x18\x12\x03D\
    \x08:\n\x0c\n\x05\x04\x07\x02\x18\x04\x12\x03D\x08\x10\n\x0c\n\x05\x04\
    \x07\x02\x18\x05\x12\x03D\x11\x16\n\x0c\n\x05\x04\x07\x02\x18\x01\x12\
    \x03D\x174\n\x0c\n\x05\x04\x07\x02\x18\x03\x12\x03D79\n\x0b\n\x04\x04\
    \x07\x02\x19\x12\x03E\x08&\n\x0c\n\x05\x04\x07\x02\x19\x04\x12\x03E\x08\
    \x10\n\x0c\n\x05\x04\x07\x02\x19\x05\x12\x03E\x11\x15\n\x0c\n\x05\x04\
    \x07\x02\x19\x01\x12\x03E\x16\x20\n\x0c\n\x05\x04\x07\x02\x19\x03\x12\
    \x03E#%\n\x0b\n\x04\x04\x07\x02\x1a\x12\x03F\x08*\n\x0c\n\x05\x04\x07\
    \x02\x1a\x04\x12\x03F\x08\x10\n\x0c\n\x05\x04\x07\x02\x1a\x06\x12\x03F\
    \x11\x1f\n\x0c\n\x05\x04\x07\x02\x1a\x01\x12\x03F\x20$\n\x0c\n\x05\x04\
    \x07\x02\x1a\x03\x12\x03F')\n\x0b\n\x04\x04\x07\x02\x1b\x12\x03G\x08-\n\
    \x0c\n\x05\x04\x07\x02\x1b\x04\x12\x03G\x08\x10\n\x0c\n\x05\x04\x07\x02\
    \x1b\x05\x12\x03G\x11\x17\n\x0c\n\x05\x04\x07\x02\x1b\x01\x12\x03G\x18'\
    \n\x0c\n\x05\x04\x07\x02\x1b\x03\x12\x03G*,\n\x0b\n\x04\x04\x07\x02\x1c\
    \x12\x03H\x08<\n\x0c\n\x05\x04\x07\x02\x1c\x04\x12\x03H\x08\x10\n\x0c\n\
    \x05\x04\x07\x02\x1c\x05\x12\x03H\x11\x17\n\x0c\n\x05\x04\x07\x02\x1c\
    \x01\x12\x03H\x186\n\x0c\n\x05\x04\x07\x02\x1c\x03\x12\x03H9;\n\x0b\n\
    \x04\x04\x07\x02\x1d\x12\x03I\x08=\n\x0c\n\x05\x04\x07\x02\x1d\x04\x12\
    \x03I\x08\x10\n\x0c\n\x05\x04\x07\x02\x1d\x05\x12\x03I\x11\x17\n\x0c\n\
    \x05\x04\x07\x02\x1d\x01\x12\x03I\x187\n\x0c\n\x05\x04\x07\x02\x1d\x03\
    \x12\x03I:<\n\n\n\x02\x04\x08\x12\x04L\0S\x01\n\n\n\x03\x04\x08\x01\x12\
    \x03L\x08\x15\n\x0b\n\x04\x04\x08\x02\0\x12\x03M\x08U\n\x0c\n\x05\x04\
    \x08\x02\0\x04\x12\x03M\x08\x10\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x03M\
    \x11\x17\n\x0c\n\x05\x04\x08\x02\0\x01\x12\x03M\x18\x1d\n\x0c\n\x05\x04\
    \x08\x02\0\x03\x12\x03M\x20!\n\x0c\n\x05\x04\x08\x02\0\x08\x12\x03M\"T\n\
    \x0f\n\x08\x04\x08\x02\0\x08\xd0\x86\x03\x12\x03M#S\n\x0b\n\x04\x04\x08\
    \x02\x01\x12\x03N\x08n\n\x0c\n\x05\x04\x08\x02\x01\x04\x12\x03N\x08\x10\
    \n\x0c\n\x05\x04\x08\x02\x01\x05\x12\x03N\x11\x17\n\x0c\n\x05\x04\x08\
    \x02\x01\x01\x12\x03N\x18\x20\n\x0c\n\x05\x04\x08\x02\x01\x03\x12\x03N#$\
    \n\x0c\n\x05\x04\x08\x02\x01\x08\x12\x03N%m\n\x0f\n\x08\x04\x08\x02\x01\
    \x08\xd0\x86\x03\x12\x03N&l\n\x0b\n\x04\x04\x08\x02\x02\x12\x03O\x08[\n\
    \x0c\n\x05\x04\x08\x02\x02\x04\x12\x03O\x08\x10\n\x0c\n\x05\x04\x08\x02\
    \x02\x05\x12\x03O\x11\x17\n\x0c\n\x05\x04\x08\x02\x02\x01\x12\x03O\x18%\
    \n\x0c\n\x05\x04\x08\x02\x02\x03\x12\x03O()\n\x0c\n\x05\x04\x08\x02\x02\
    \x08\x12\x03O*Z\n\x0f\n\x08\x04\x08\x02\x02\x08\xd0\x86\x03\x12\x03O+Y\n\
    \x0b\n\x04\x04\x08\x02\x03\x12\x03P\x08k\n\x0c\n\x05\x04\x08\x02\x03\x04\
    \x12\x03P\x08\x10\n\x0c\n\x05\x04\x08\x02\x03\x05\x12\x03P\x11\x17\n\x0c\
    \n\x05\x04\x08\x02\x03\x01\x12\x03P\x18/\n\x0c\n\x05\x04\x08\x02\x03\x03\
    \x12\x03P23\n\x0c\n\x05\x04\x08\x02\x03\x08\x12\x03P4j\n\x0f\n\x08\x04\
    \x08\x02\x03\x08\xd0\x86\x03\x12\x03P5i\n\x0b\n\x04\x04\x08\x02\x04\x12\
    \x03Q\x08a\n\x0c\n\x05\x04\x08\x02\x04\x04\x12\x03Q\x08\x10\n\x0c\n\x05\
    \x04\x08\x02\x04\x05\x12\x03Q\x11\x17\n\x0c\n\x05\x04\x08\x02\x04\x01\
    \x12\x03Q\x18*\n\x0c\n\x05\x04\x08\x02\x04\x03\x12\x03Q-.\n\x0c\n\x05\
    \x04\x08\x02\x04\x08\x12\x03Q/`\n\x0f\n\x08\x04\x08\x02\x04\x08\xd0\x86\
    \x03\x12\x03Q0_\n\x0b\n\x04\x04\x08\x02\x05\x12\x03R\x08k\n\x0c\n\x05\
    \x04\x08\x02\x05\x04\x12\x03R\x08\x10\n\x0c\n\x05\x04\x08\x02\x05\x05\
    \x12\x03R\x11\x17\n\x0c\n\x05\x04\x08\x02\x05\x01\x12\x03R\x18\x1d\n\x0c\
    \n\x05\x04\x08\x02\x05\x03\x12\x03R\x20!\n\x0c\n\x05\x04\x08\x02\x05\x08\
    \x12\x03R\"j\n\x0f\n\x08\x04\x08\x02\x05\x08\xd0\x86\x03\x12\x03R#i\n\n\
    \n\x02\x04\t\x12\x04U\0W\x01\n\n\n\x03\x04\t\x01\x12\x03U\x08(\n\x0b\n\
    \x04\x04\t\x02\0\x12\x03V\x089\n\x0c\n\x05\x04\t\x02\0\x04\x12\x03V\x08\
    \x10\n\x0c\n\x05\x04\t\x02\0\x06\x12\x03V\x11'\n\x0c\n\x05\x04\t\x02\0\
    \x01\x12\x03V(4\n\x0c\n\x05\x04\t\x02\0\x03\x12\x03V78\n\n\n\x02\x06\0\
    \x12\x04Y\0g\x01\n\n\n\x03\x06\0\x01\x12\x03Y\x08\x0c\n\n\n\x03\x06\0\
    \x03\x12\x03Z\x08e\n\r\n\x06\x06\0\x03\xd0\x86\x03\x12\x03Z\x08e\n\x0c\n\
    \x04\x06\0\x02\0\x12\x04\\\x08^\t\n\x0c\n\x05\x06\0\x02\0\x01\x12\x03\\\
    \x0c$\n\x0c\n\x05\x06\0\x02\0\x02\x12\x03\\&M\n\r\n\x05\x06\0\x02\0\x03\
    \x12\x04\\X\x80\x01\n\x0c\n\x05\x06\0\x02\0\x04\x12\x03]\x10X\n\x0f\n\
    \x08\x06\0\x02\0\x04\xd0\x86\x03\x12\x03]\x10X\n\x0c\n\x04\x06\0\x02\x01\
    \x12\x04`\x08b\t\n\x0c\n\x05\x06\0\x02\x01\x01\x12\x03`\x0c+\n\x0c\n\x05\
    \x06\0\x02\x01\x02\x12\x03`-[\n\r\n\x05\x06\0\x02\x01\x03\x12\x04`f\x95\
    \x01\n\r\n\x05\x06\0\x02\x01\x04\x12\x04a\x10\x82\x01\n\x10\n\x08\x06\0\
    \x02\x01\x04\xd0\x86\x03\x12\x04a\x10\x82\x01\n\x0c\n\x04\x06\0\x02\x02\
    \x12\x04d\x08f\t\n\x0c\n\x05\x06\0\x02\x02\x01\x12\x03d\x0c\x1d\n\x0c\n\
    \x05\x06\0\x02\x02\x02\x12\x03d\x1f?\n\x0c\n\x05\x06\0\x02\x02\x03\x12\
    \x03dJk\n\x0c\n\x05\x06\0\x02\x02\x04\x12\x03e\x10r\n\x0f\n\x08\x06\0\
    \x02\x02\x04\xd0\x86\x03\x12\x03e\x10r\
";

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