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

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

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

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

//! Generated file from `steammessages_econ.steamclient.proto`
// Generated for lite runtime

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

// @@protoc_insertion_point(message:CEcon_GetInventoryItemsWithDescriptions_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CEcon_GetInventoryItemsWithDescriptions_Request {
    // message fields
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Request.contextid)
    pub contextid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Request.get_descriptions)
    pub get_descriptions: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Request.get_asset_properties)
    pub get_asset_properties: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Request.for_trade_offer_verification)
    pub for_trade_offer_verification: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Request.language)
    pub language: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Request.filters)
    pub filters: ::steam_vent_proto_common::protobuf::MessageField<cecon_get_inventory_items_with_descriptions_request::FilterOptions>,
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Request.start_assetid)
    pub start_assetid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Request.count)
    pub count: ::std::option::Option<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:CEcon_GetInventoryItemsWithDescriptions_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed64 steamid = 1;

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

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

    pub fn has_steamid(&self) -> bool {
        self.steamid.is_some()
    }

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

    // optional uint32 appid = 2;

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

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

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

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

    // optional uint64 contextid = 3;

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

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

    pub fn has_contextid(&self) -> bool {
        self.contextid.is_some()
    }

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

    // optional bool get_descriptions = 4;

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

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

    pub fn has_get_descriptions(&self) -> bool {
        self.get_descriptions.is_some()
    }

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

    // optional bool get_asset_properties = 11;

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

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

    pub fn has_get_asset_properties(&self) -> bool {
        self.get_asset_properties.is_some()
    }

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

    // optional bool for_trade_offer_verification = 10;

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

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

    pub fn has_for_trade_offer_verification(&self) -> bool {
        self.for_trade_offer_verification.is_some()
    }

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

    // optional string language = 5;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_language(&mut self) -> &mut ::std::string::String {
        if self.language.is_none() {
            self.language = ::std::option::Option::Some(::std::string::String::new());
        }
        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 uint64 start_assetid = 8;

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

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

    pub fn has_start_assetid(&self) -> bool {
        self.start_assetid.is_some()
    }

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

    // optional int32 count = 9;

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

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

    pub fn has_count(&self) -> bool {
        self.count.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                9 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                16 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.contextid = ::std::option::Option::Some(is.read_uint64()?);
                },
                32 => {
                    self.get_descriptions = ::std::option::Option::Some(is.read_bool()?);
                },
                88 => {
                    self.get_asset_properties = ::std::option::Option::Some(is.read_bool()?);
                },
                80 => {
                    self.for_trade_offer_verification = ::std::option::Option::Some(is.read_bool()?);
                },
                42 => {
                    self.language = ::std::option::Option::Some(is.read_string()?);
                },
                50 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.filters)?;
                },
                64 => {
                    self.start_assetid = ::std::option::Option::Some(is.read_uint64()?);
                },
                72 => {
                    self.count = ::std::option::Option::Some(is.read_int32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.steamid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.contextid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
        }
        if let Some(v) = self.get_descriptions {
            my_size += 1 + 1;
        }
        if let Some(v) = self.get_asset_properties {
            my_size += 1 + 1;
        }
        if let Some(v) = self.for_trade_offer_verification {
            my_size += 1 + 1;
        }
        if let Some(v) = self.language.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &v);
        }
        if let Some(v) = self.filters.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.start_assetid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(8, v);
        }
        if let Some(v) = self.count {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(9, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.contextid {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.get_descriptions {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.get_asset_properties {
            os.write_bool(11, v)?;
        }
        if let Some(v) = self.for_trade_offer_verification {
            os.write_bool(10, v)?;
        }
        if let Some(v) = self.language.as_ref() {
            os.write_string(5, v)?;
        }
        if let Some(v) = self.filters.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        }
        if let Some(v) = self.start_assetid {
            os.write_uint64(8, v)?;
        }
        if let Some(v) = self.count {
            os.write_int32(9, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.appid = ::std::option::Option::None;
        self.contextid = ::std::option::Option::None;
        self.get_descriptions = ::std::option::Option::None;
        self.get_asset_properties = ::std::option::Option::None;
        self.for_trade_offer_verification = ::std::option::Option::None;
        self.language = ::std::option::Option::None;
        self.filters.clear();
        self.start_assetid = ::std::option::Option::None;
        self.count = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CEcon_GetInventoryItemsWithDescriptions_Request {
        static instance: CEcon_GetInventoryItemsWithDescriptions_Request = CEcon_GetInventoryItemsWithDescriptions_Request {
            steamid: ::std::option::Option::None,
            appid: ::std::option::Option::None,
            contextid: ::std::option::Option::None,
            get_descriptions: ::std::option::Option::None,
            get_asset_properties: ::std::option::Option::None,
            for_trade_offer_verification: ::std::option::Option::None,
            language: ::std::option::Option::None,
            filters: ::steam_vent_proto_common::protobuf::MessageField::none(),
            start_assetid: ::std::option::Option::None,
            count: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CEcon_GetInventoryItemsWithDescriptions_Request`
pub mod cecon_get_inventory_items_with_descriptions_request {
    // @@protoc_insertion_point(message:CEcon_GetInventoryItemsWithDescriptions_Request.FilterOptions)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct FilterOptions {
        // message fields
        // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Request.FilterOptions.assetids)
        pub assetids: ::std::vec::Vec<u64>,
        // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Request.FilterOptions.currencyids)
        pub currencyids: ::std::vec::Vec<u32>,
        // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Request.FilterOptions.tradable_only)
        pub tradable_only: ::std::option::Option<bool>,
        // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Request.FilterOptions.marketable_only)
        pub marketable_only: ::std::option::Option<bool>,
        // special fields
        // @@protoc_insertion_point(special_field:CEcon_GetInventoryItemsWithDescriptions_Request.FilterOptions.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional bool tradable_only = 3;

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

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

        pub fn has_tradable_only(&self) -> bool {
            self.tradable_only.is_some()
        }

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

        // optional bool marketable_only = 4;

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

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

        pub fn has_marketable_only(&self) -> bool {
            self.marketable_only.is_some()
        }

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

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

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

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        is.read_repeated_packed_uint64_into(&mut self.assetids)?;
                    },
                    8 => {
                        self.assetids.push(is.read_uint64()?);
                    },
                    18 => {
                        is.read_repeated_packed_uint32_into(&mut self.currencyids)?;
                    },
                    16 => {
                        self.currencyids.push(is.read_uint32()?);
                    },
                    24 => {
                        self.tradable_only = ::std::option::Option::Some(is.read_bool()?);
                    },
                    32 => {
                        self.marketable_only = ::std::option::Option::Some(is.read_bool()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            for value in &self.assetids {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, *value);
            };
            for value in &self.currencyids {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, *value);
            };
            if let Some(v) = self.tradable_only {
                my_size += 1 + 1;
            }
            if let Some(v) = self.marketable_only {
                my_size += 1 + 1;
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            for v in &self.assetids {
                os.write_uint64(1, *v)?;
            };
            for v in &self.currencyids {
                os.write_uint32(2, *v)?;
            };
            if let Some(v) = self.tradable_only {
                os.write_bool(3, v)?;
            }
            if let Some(v) = self.marketable_only {
                os.write_bool(4, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

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

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

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

        fn clear(&mut self) {
            self.assetids.clear();
            self.currencyids.clear();
            self.tradable_only = ::std::option::Option::None;
            self.marketable_only = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static FilterOptions {
            static instance: FilterOptions = FilterOptions {
                assetids: ::std::vec::Vec::new(),
                currencyids: ::std::vec::Vec::new(),
                tradable_only: ::std::option::Option::None,
                marketable_only: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:CEcon_Asset)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CEcon_Asset {
    // message fields
    // @@protoc_insertion_point(field:CEcon_Asset.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CEcon_Asset.contextid)
    pub contextid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CEcon_Asset.assetid)
    pub assetid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CEcon_Asset.classid)
    pub classid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CEcon_Asset.instanceid)
    pub instanceid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CEcon_Asset.currencyid)
    pub currencyid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CEcon_Asset.amount)
    pub amount: ::std::option::Option<i64>,
    // @@protoc_insertion_point(field:CEcon_Asset.missing)
    pub missing: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CEcon_Asset.est_usd)
    pub est_usd: ::std::option::Option<i64>,
    // special fields
    // @@protoc_insertion_point(special_field:CEcon_Asset.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional uint64 contextid = 2;

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

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

    pub fn has_contextid(&self) -> bool {
        self.contextid.is_some()
    }

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

    // optional uint64 assetid = 3;

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

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

    pub fn has_assetid(&self) -> bool {
        self.assetid.is_some()
    }

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

    // optional uint64 classid = 4;

    pub fn 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 = 5;

    pub fn 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 uint32 currencyid = 6;

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

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

    pub fn has_currencyid(&self) -> bool {
        self.currencyid.is_some()
    }

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

    // optional int64 amount = 7;

    pub fn amount(&self) -> i64 {
        self.amount.unwrap_or(0)
    }

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

    pub fn has_amount(&self) -> bool {
        self.amount.is_some()
    }

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

    // optional bool missing = 8;

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

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

    pub fn has_missing(&self) -> bool {
        self.missing.is_some()
    }

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

    // optional int64 est_usd = 9;

    pub fn est_usd(&self) -> i64 {
        self.est_usd.unwrap_or(0)
    }

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

    pub fn has_est_usd(&self) -> bool {
        self.est_usd.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.contextid = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.assetid = ::std::option::Option::Some(is.read_uint64()?);
                },
                32 => {
                    self.classid = ::std::option::Option::Some(is.read_uint64()?);
                },
                40 => {
                    self.instanceid = ::std::option::Option::Some(is.read_uint64()?);
                },
                48 => {
                    self.currencyid = ::std::option::Option::Some(is.read_uint32()?);
                },
                56 => {
                    self.amount = ::std::option::Option::Some(is.read_int64()?);
                },
                64 => {
                    self.missing = ::std::option::Option::Some(is.read_bool()?);
                },
                72 => {
                    self.est_usd = ::std::option::Option::Some(is.read_int64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.contextid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.assetid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
        }
        if let Some(v) = self.classid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(4, v);
        }
        if let Some(v) = self.instanceid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(5, v);
        }
        if let Some(v) = self.currencyid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.amount {
            my_size += ::steam_vent_proto_common::protobuf::rt::int64_size(7, v);
        }
        if let Some(v) = self.missing {
            my_size += 1 + 1;
        }
        if let Some(v) = self.est_usd {
            my_size += ::steam_vent_proto_common::protobuf::rt::int64_size(9, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.contextid {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.assetid {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.classid {
            os.write_uint64(4, v)?;
        }
        if let Some(v) = self.instanceid {
            os.write_uint64(5, v)?;
        }
        if let Some(v) = self.currencyid {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.amount {
            os.write_int64(7, v)?;
        }
        if let Some(v) = self.missing {
            os.write_bool(8, v)?;
        }
        if let Some(v) = self.est_usd {
            os.write_int64(9, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.contextid = ::std::option::Option::None;
        self.assetid = ::std::option::Option::None;
        self.classid = ::std::option::Option::None;
        self.instanceid = ::std::option::Option::None;
        self.currencyid = ::std::option::Option::None;
        self.amount = ::std::option::Option::None;
        self.missing = ::std::option::Option::None;
        self.est_usd = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CEcon_Asset {
        static instance: CEcon_Asset = CEcon_Asset {
            appid: ::std::option::Option::None,
            contextid: ::std::option::Option::None,
            assetid: ::std::option::Option::None,
            classid: ::std::option::Option::None,
            instanceid: ::std::option::Option::None,
            currencyid: ::std::option::Option::None,
            amount: ::std::option::Option::None,
            missing: ::std::option::Option::None,
            est_usd: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional string type = 1;

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

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

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

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

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

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

    // optional string value = 2;

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

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

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

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_value(&mut self) -> &mut ::std::string::String {
        if self.value.is_none() {
            self.value = ::std::option::Option::Some(::std::string::String::new());
        }
        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 color(&self) -> &str {
        match self.color.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_color(&mut self) -> &mut ::std::string::String {
        if self.color.is_none() {
            self.color = ::std::option::Option::Some(::std::string::String::new());
        }
        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 label(&self) -> &str {
        match self.label.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_label(&mut self) -> &mut ::std::string::String {
        if self.label.is_none() {
            self.label = ::std::option::Option::Some(::std::string::String::new());
        }
        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())
    }

    // optional string name = 5;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional string link = 1;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_link(&mut self) -> &mut ::std::string::String {
        if self.link.is_none() {
            self.link = ::std::option::Option::Some(::std::string::String::new());
        }
        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 name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// @@protoc_insertion_point(message:CEconItem_Description)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CEconItem_Description {
    // message fields
    // @@protoc_insertion_point(field:CEconItem_Description.appid)
    pub appid: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CEconItem_Description.classid)
    pub classid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CEconItem_Description.instanceid)
    pub instanceid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CEconItem_Description.currency)
    pub currency: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CEconItem_Description.background_color)
    pub background_color: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Description.icon_url)
    pub icon_url: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Description.icon_url_large)
    pub icon_url_large: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Description.descriptions)
    pub descriptions: ::std::vec::Vec<CEconItem_DescriptionLine>,
    // @@protoc_insertion_point(field:CEconItem_Description.tradable)
    pub tradable: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CEconItem_Description.actions)
    pub actions: ::std::vec::Vec<CEconItem_Action>,
    // @@protoc_insertion_point(field:CEconItem_Description.owner_descriptions)
    pub owner_descriptions: ::std::vec::Vec<CEconItem_DescriptionLine>,
    // @@protoc_insertion_point(field:CEconItem_Description.owner_actions)
    pub owner_actions: ::std::vec::Vec<CEconItem_Action>,
    // @@protoc_insertion_point(field:CEconItem_Description.fraudwarnings)
    pub fraudwarnings: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Description.name)
    pub name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Description.name_color)
    pub name_color: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Description.type)
    pub type_: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Description.market_name)
    pub market_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Description.market_hash_name)
    pub market_hash_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Description.market_fee)
    pub market_fee: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Description.market_fee_app)
    pub market_fee_app: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CEconItem_Description.contained_item)
    pub contained_item: ::steam_vent_proto_common::protobuf::MessageField<CEconItem_Description>,
    // @@protoc_insertion_point(field:CEconItem_Description.market_actions)
    pub market_actions: ::std::vec::Vec<CEconItem_Action>,
    // @@protoc_insertion_point(field:CEconItem_Description.commodity)
    pub commodity: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CEconItem_Description.market_tradable_restriction)
    pub market_tradable_restriction: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CEconItem_Description.market_marketable_restriction)
    pub market_marketable_restriction: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CEconItem_Description.marketable)
    pub marketable: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CEconItem_Description.tags)
    pub tags: ::std::vec::Vec<CEconItem_Tag>,
    // @@protoc_insertion_point(field:CEconItem_Description.item_expiration)
    pub item_expiration: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Description.market_buy_country_restriction)
    pub market_buy_country_restriction: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Description.market_sell_country_restriction)
    pub market_sell_country_restriction: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Description.sealed)
    pub sealed: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CEconItem_Description.container_properties)
    pub container_properties: ::steam_vent_proto_common::protobuf::MessageField<CEconItem_ContainerProperties>,
    // special fields
    // @@protoc_insertion_point(special_field:CEconItem_Description.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional int32 appid = 1;

    pub fn 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 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 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 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 background_color(&self) -> &str {
        match self.background_color.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_background_color(&mut self) -> &mut ::std::string::String {
        if self.background_color.is_none() {
            self.background_color = ::std::option::Option::Some(::std::string::String::new());
        }
        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 icon_url(&self) -> &str {
        match self.icon_url.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_icon_url(&mut self) -> &mut ::std::string::String {
        if self.icon_url.is_none() {
            self.icon_url = ::std::option::Option::Some(::std::string::String::new());
        }
        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 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 = ::std::option::Option::None;
    }

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_icon_url_large(&mut self) -> &mut ::std::string::String {
        if self.icon_url_large.is_none() {
            self.icon_url_large = ::std::option::Option::Some(::std::string::String::new());
        }
        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())
    }

    // optional bool tradable = 9;

    pub fn 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);
    }

    // optional string name = 14;

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

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

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

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

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

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

    // optional string name_color = 15;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name_color(&mut self) -> &mut ::std::string::String {
        if self.name_color.is_none() {
            self.name_color = ::std::option::Option::Some(::std::string::String::new());
        }
        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 type_(&self) -> &str {
        match self.type_.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

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

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

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

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

    // optional string market_name = 17;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_market_name(&mut self) -> &mut ::std::string::String {
        if self.market_name.is_none() {
            self.market_name = ::std::option::Option::Some(::std::string::String::new());
        }
        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 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 = ::std::option::Option::None;
    }

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_market_hash_name(&mut self) -> &mut ::std::string::String {
        if self.market_hash_name.is_none() {
            self.market_hash_name = ::std::option::Option::Some(::std::string::String::new());
        }
        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 market_fee(&self) -> &str {
        match self.market_fee.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_market_fee(&mut self) -> &mut ::std::string::String {
        if self.market_fee.is_none() {
            self.market_fee = ::std::option::Option::Some(::std::string::String::new());
        }
        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 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 bool commodity = 22;

    pub fn 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 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 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 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);
    }

    // optional string item_expiration = 27;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_item_expiration(&mut self) -> &mut ::std::string::String {
        if self.item_expiration.is_none() {
            self.item_expiration = ::std::option::Option::Some(::std::string::String::new());
        }
        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 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 = ::std::option::Option::None;
    }

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_market_buy_country_restriction(&mut self) -> &mut ::std::string::String {
        if self.market_buy_country_restriction.is_none() {
            self.market_buy_country_restriction = ::std::option::Option::Some(::std::string::String::new());
        }
        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 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 = ::std::option::Option::None;
    }

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_market_sell_country_restriction(&mut self) -> &mut ::std::string::String {
        if self.market_sell_country_restriction.is_none() {
            self.market_sell_country_restriction = ::std::option::Option::Some(::std::string::String::new());
        }
        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())
    }

    // optional bool sealed = 32;

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

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

    pub fn has_sealed(&self) -> bool {
        self.sealed.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_int32()?);
                },
                16 => {
                    self.classid = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.instanceid = ::std::option::Option::Some(is.read_uint64()?);
                },
                32 => {
                    self.currency = ::std::option::Option::Some(is.read_bool()?);
                },
                42 => {
                    self.background_color = ::std::option::Option::Some(is.read_string()?);
                },
                50 => {
                    self.icon_url = ::std::option::Option::Some(is.read_string()?);
                },
                58 => {
                    self.icon_url_large = ::std::option::Option::Some(is.read_string()?);
                },
                66 => {
                    self.descriptions.push(is.read_message()?);
                },
                72 => {
                    self.tradable = ::std::option::Option::Some(is.read_bool()?);
                },
                82 => {
                    self.actions.push(is.read_message()?);
                },
                90 => {
                    self.owner_descriptions.push(is.read_message()?);
                },
                98 => {
                    self.owner_actions.push(is.read_message()?);
                },
                106 => {
                    self.fraudwarnings.push(is.read_string()?);
                },
                114 => {
                    self.name = ::std::option::Option::Some(is.read_string()?);
                },
                122 => {
                    self.name_color = ::std::option::Option::Some(is.read_string()?);
                },
                130 => {
                    self.type_ = ::std::option::Option::Some(is.read_string()?);
                },
                138 => {
                    self.market_name = ::std::option::Option::Some(is.read_string()?);
                },
                146 => {
                    self.market_hash_name = ::std::option::Option::Some(is.read_string()?);
                },
                154 => {
                    self.market_fee = ::std::option::Option::Some(is.read_string()?);
                },
                224 => {
                    self.market_fee_app = ::std::option::Option::Some(is.read_int32()?);
                },
                162 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.contained_item)?;
                },
                170 => {
                    self.market_actions.push(is.read_message()?);
                },
                176 => {
                    self.commodity = ::std::option::Option::Some(is.read_bool()?);
                },
                184 => {
                    self.market_tradable_restriction = ::std::option::Option::Some(is.read_int32()?);
                },
                192 => {
                    self.market_marketable_restriction = ::std::option::Option::Some(is.read_int32()?);
                },
                200 => {
                    self.marketable = ::std::option::Option::Some(is.read_bool()?);
                },
                210 => {
                    self.tags.push(is.read_message()?);
                },
                218 => {
                    self.item_expiration = ::std::option::Option::Some(is.read_string()?);
                },
                242 => {
                    self.market_buy_country_restriction = ::std::option::Option::Some(is.read_string()?);
                },
                250 => {
                    self.market_sell_country_restriction = ::std::option::Option::Some(is.read_string()?);
                },
                256 => {
                    self.sealed = ::std::option::Option::Some(is.read_bool()?);
                },
                266 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.container_properties)?;
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
        }
        if let Some(v) = self.classid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.instanceid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
        }
        if let Some(v) = self.currency {
            my_size += 1 + 1;
        }
        if let Some(v) = self.background_color.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &v);
        }
        if let Some(v) = self.icon_url.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.icon_url_large.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
        }
        for value in &self.descriptions {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.tradable {
            my_size += 1 + 1;
        }
        for value in &self.actions {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.owner_descriptions {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.owner_actions {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.fraudwarnings {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(13, &value);
        };
        if let Some(v) = self.name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(14, &v);
        }
        if let Some(v) = self.name_color.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(15, &v);
        }
        if let Some(v) = self.type_.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(16, &v);
        }
        if let Some(v) = self.market_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(17, &v);
        }
        if let Some(v) = self.market_hash_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(18, &v);
        }
        if let Some(v) = self.market_fee.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(19, &v);
        }
        if let Some(v) = self.market_fee_app {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(28, v);
        }
        if let Some(v) = self.contained_item.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.market_actions {
            let len = value.compute_size();
            my_size += 2 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.commodity {
            my_size += 2 + 1;
        }
        if let Some(v) = self.market_tradable_restriction {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(23, v);
        }
        if let Some(v) = self.market_marketable_restriction {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(24, v);
        }
        if let Some(v) = self.marketable {
            my_size += 2 + 1;
        }
        for value in &self.tags {
            let len = value.compute_size();
            my_size += 2 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.item_expiration.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(27, &v);
        }
        if let Some(v) = self.market_buy_country_restriction.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(30, &v);
        }
        if let Some(v) = self.market_sell_country_restriction.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(31, &v);
        }
        if let Some(v) = self.sealed {
            my_size += 2 + 1;
        }
        if let Some(v) = self.container_properties.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_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(v) = self.background_color.as_ref() {
            os.write_string(5, v)?;
        }
        if let Some(v) = self.icon_url.as_ref() {
            os.write_string(6, v)?;
        }
        if let Some(v) = self.icon_url_large.as_ref() {
            os.write_string(7, v)?;
        }
        for v in &self.descriptions {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
        };
        if let Some(v) = self.tradable {
            os.write_bool(9, v)?;
        }
        for v in &self.actions {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
        };
        for v in &self.owner_descriptions {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(11, v, os)?;
        };
        for v in &self.owner_actions {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(12, v, os)?;
        };
        for v in &self.fraudwarnings {
            os.write_string(13, &v)?;
        };
        if let Some(v) = self.name.as_ref() {
            os.write_string(14, v)?;
        }
        if let Some(v) = self.name_color.as_ref() {
            os.write_string(15, v)?;
        }
        if let Some(v) = self.type_.as_ref() {
            os.write_string(16, v)?;
        }
        if let Some(v) = self.market_name.as_ref() {
            os.write_string(17, v)?;
        }
        if let Some(v) = self.market_hash_name.as_ref() {
            os.write_string(18, v)?;
        }
        if let Some(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(v) = self.contained_item.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(20, v, os)?;
        }
        for v in &self.market_actions {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(21, v, 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 {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(26, v, os)?;
        };
        if let Some(v) = self.item_expiration.as_ref() {
            os.write_string(27, v)?;
        }
        if let Some(v) = self.market_buy_country_restriction.as_ref() {
            os.write_string(30, v)?;
        }
        if let Some(v) = self.market_sell_country_restriction.as_ref() {
            os.write_string(31, v)?;
        }
        if let Some(v) = self.sealed {
            os.write_bool(32, v)?;
        }
        if let Some(v) = self.container_properties.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(33, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    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 = ::std::option::Option::None;
        self.icon_url = ::std::option::Option::None;
        self.icon_url_large = ::std::option::Option::None;
        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 = ::std::option::Option::None;
        self.name_color = ::std::option::Option::None;
        self.type_ = ::std::option::Option::None;
        self.market_name = ::std::option::Option::None;
        self.market_hash_name = ::std::option::Option::None;
        self.market_fee = ::std::option::Option::None;
        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 = ::std::option::Option::None;
        self.market_buy_country_restriction = ::std::option::Option::None;
        self.market_sell_country_restriction = ::std::option::Option::None;
        self.sealed = ::std::option::Option::None;
        self.container_properties.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CEconItem_Description {
        static instance: CEconItem_Description = CEconItem_Description {
            appid: ::std::option::Option::None,
            classid: ::std::option::Option::None,
            instanceid: ::std::option::Option::None,
            currency: ::std::option::Option::None,
            background_color: ::std::option::Option::None,
            icon_url: ::std::option::Option::None,
            icon_url_large: ::std::option::Option::None,
            descriptions: ::std::vec::Vec::new(),
            tradable: ::std::option::Option::None,
            actions: ::std::vec::Vec::new(),
            owner_descriptions: ::std::vec::Vec::new(),
            owner_actions: ::std::vec::Vec::new(),
            fraudwarnings: ::std::vec::Vec::new(),
            name: ::std::option::Option::None,
            name_color: ::std::option::Option::None,
            type_: ::std::option::Option::None,
            market_name: ::std::option::Option::None,
            market_hash_name: ::std::option::Option::None,
            market_fee: ::std::option::Option::None,
            market_fee_app: ::std::option::Option::None,
            contained_item: ::steam_vent_proto_common::protobuf::MessageField::none(),
            market_actions: ::std::vec::Vec::new(),
            commodity: ::std::option::Option::None,
            market_tradable_restriction: ::std::option::Option::None,
            market_marketable_restriction: ::std::option::Option::None,
            marketable: ::std::option::Option::None,
            tags: ::std::vec::Vec::new(),
            item_expiration: ::std::option::Option::None,
            market_buy_country_restriction: ::std::option::Option::None,
            market_sell_country_restriction: ::std::option::Option::None,
            sealed: ::std::option::Option::None,
            container_properties: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CEconItem_Tag)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CEconItem_Tag {
    // message fields
    // @@protoc_insertion_point(field:CEconItem_Tag.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CEconItem_Tag.category)
    pub category: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Tag.internal_name)
    pub internal_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Tag.localized_category_name)
    pub localized_category_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Tag.localized_tag_name)
    pub localized_tag_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CEconItem_Tag.color)
    pub color: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CEconItem_Tag.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional string category = 2;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_category(&mut self) -> &mut ::std::string::String {
        if self.category.is_none() {
            self.category = ::std::option::Option::Some(::std::string::String::new());
        }
        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 internal_name(&self) -> &str {
        match self.internal_name.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_internal_name(&mut self) -> &mut ::std::string::String {
        if self.internal_name.is_none() {
            self.internal_name = ::std::option::Option::Some(::std::string::String::new());
        }
        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 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 = ::std::option::Option::None;
    }

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_localized_category_name(&mut self) -> &mut ::std::string::String {
        if self.localized_category_name.is_none() {
            self.localized_category_name = ::std::option::Option::Some(::std::string::String::new());
        }
        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 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 = ::std::option::Option::None;
    }

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_localized_tag_name(&mut self) -> &mut ::std::string::String {
        if self.localized_tag_name.is_none() {
            self.localized_tag_name = ::std::option::Option::Some(::std::string::String::new());
        }
        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 color(&self) -> &str {
        match self.color.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_color(&mut self) -> &mut ::std::string::String {
        if self.color.is_none() {
            self.color = ::std::option::Option::Some(::std::string::String::new());
        }
        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 ::steam_vent_proto_common::protobuf::Message for CEconItem_Tag {
    const NAME: &'static str = "CEconItem_Tag";

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                18 => {
                    self.category = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    self.internal_name = ::std::option::Option::Some(is.read_string()?);
                },
                34 => {
                    self.localized_category_name = ::std::option::Option::Some(is.read_string()?);
                },
                42 => {
                    self.localized_tag_name = ::std::option::Option::Some(is.read_string()?);
                },
                50 => {
                    self.color = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.category.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.internal_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.localized_category_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.localized_tag_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &v);
        }
        if let Some(v) = self.color.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.category.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.internal_name.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.localized_category_name.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.localized_tag_name.as_ref() {
            os.write_string(5, v)?;
        }
        if let Some(v) = self.color.as_ref() {
            os.write_string(6, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.category = ::std::option::Option::None;
        self.internal_name = ::std::option::Option::None;
        self.localized_category_name = ::std::option::Option::None;
        self.localized_tag_name = ::std::option::Option::None;
        self.color = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CEconItem_Tag {
        static instance: CEconItem_Tag = CEconItem_Tag {
            appid: ::std::option::Option::None,
            category: ::std::option::Option::None,
            internal_name: ::std::option::Option::None,
            localized_category_name: ::std::option::Option::None,
            localized_tag_name: ::std::option::Option::None,
            color: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional uint64 classid = 1;

    pub fn 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 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 ::steam_vent_proto_common::protobuf::Message for CEconItem_ClassIdentifiers {
    const NAME: &'static str = "CEconItem_ClassIdentifiers";

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

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

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

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

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

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

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

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

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

// @@protoc_insertion_point(message:CEconItem_ContainerProperties)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CEconItem_ContainerProperties {
    // message fields
    // @@protoc_insertion_point(field:CEconItem_ContainerProperties.contained_items)
    pub contained_items: ::std::vec::Vec<CEconItem_ClassIdentifiers>,
    // @@protoc_insertion_point(field:CEconItem_ContainerProperties.search_tags)
    pub search_tags: ::std::vec::Vec<CEconItem_Tag>,
    // special fields
    // @@protoc_insertion_point(special_field:CEconItem_ContainerProperties.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.contained_items.push(is.read_message()?);
                },
                18 => {
                    self.search_tags.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

// @@protoc_insertion_point(message:CEconItem_AssetProperty)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CEconItem_AssetProperty {
    // message fields
    // @@protoc_insertion_point(field:CEconItem_AssetProperty.propertyid)
    pub propertyid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CEconItem_AssetProperty.int_value)
    pub int_value: ::std::option::Option<i64>,
    // @@protoc_insertion_point(field:CEconItem_AssetProperty.float_value)
    pub float_value: ::std::option::Option<f32>,
    // special fields
    // @@protoc_insertion_point(special_field:CEconItem_AssetProperty.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 propertyid = 1;

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

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

    pub fn has_propertyid(&self) -> bool {
        self.propertyid.is_some()
    }

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

    // optional int64 int_value = 2;

    pub fn int_value(&self) -> i64 {
        self.int_value.unwrap_or(0)
    }

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

    pub fn has_int_value(&self) -> bool {
        self.int_value.is_some()
    }

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

    // optional float float_value = 3;

    pub fn float_value(&self) -> f32 {
        self.float_value.unwrap_or(0.)
    }

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

    pub fn has_float_value(&self) -> bool {
        self.float_value.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional uint64 contextid = 2;

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

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

    pub fn has_contextid(&self) -> bool {
        self.contextid.is_some()
    }

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

    // optional uint64 assetid = 3;

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

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

    pub fn has_assetid(&self) -> bool {
        self.assetid.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.contextid = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.assetid = ::std::option::Option::Some(is.read_uint64()?);
                },
                34 => {
                    self.asset_properties.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.contextid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.assetid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
        }
        for value in &self.asset_properties {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.contextid {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.assetid {
            os.write_uint64(3, v)?;
        }
        for v in &self.asset_properties {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

// @@protoc_insertion_point(message:CEcon_GetInventoryItemsWithDescriptions_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CEcon_GetInventoryItemsWithDescriptions_Response {
    // message fields
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Response.assets)
    pub assets: ::std::vec::Vec<CEcon_Asset>,
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Response.descriptions)
    pub descriptions: ::std::vec::Vec<CEconItem_Description>,
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Response.missing_assets)
    pub missing_assets: ::std::vec::Vec<CEcon_Asset>,
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Response.asset_properties)
    pub asset_properties: ::std::vec::Vec<CEconItem_AssetProperties>,
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Response.more_items)
    pub more_items: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Response.last_assetid)
    pub last_assetid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CEcon_GetInventoryItemsWithDescriptions_Response.total_inventory_count)
    pub total_inventory_count: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CEcon_GetInventoryItemsWithDescriptions_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional bool more_items = 4;

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

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

    pub fn has_more_items(&self) -> bool {
        self.more_items.is_some()
    }

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

    // optional uint64 last_assetid = 5;

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

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

    pub fn has_last_assetid(&self) -> bool {
        self.last_assetid.is_some()
    }

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

    // optional uint32 total_inventory_count = 6;

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

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

    pub fn has_total_inventory_count(&self) -> bool {
        self.total_inventory_count.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.assets.push(is.read_message()?);
                },
                18 => {
                    self.descriptions.push(is.read_message()?);
                },
                26 => {
                    self.missing_assets.push(is.read_message()?);
                },
                58 => {
                    self.asset_properties.push(is.read_message()?);
                },
                32 => {
                    self.more_items = ::std::option::Option::Some(is.read_bool()?);
                },
                40 => {
                    self.last_assetid = ::std::option::Option::Some(is.read_uint64()?);
                },
                48 => {
                    self.total_inventory_count = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.assets {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.descriptions {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.missing_assets {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.asset_properties {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.more_items {
            my_size += 1 + 1;
        }
        if let Some(v) = self.last_assetid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(5, v);
        }
        if let Some(v) = self.total_inventory_count {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.assets {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        for v in &self.descriptions {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        for v in &self.missing_assets {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        for v in &self.asset_properties {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
        };
        if let Some(v) = self.more_items {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.last_assetid {
            os.write_uint64(5, v)?;
        }
        if let Some(v) = self.total_inventory_count {
            os.write_uint32(6, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.assets.clear();
        self.descriptions.clear();
        self.missing_assets.clear();
        self.asset_properties.clear();
        self.more_items = ::std::option::Option::None;
        self.last_assetid = ::std::option::Option::None;
        self.total_inventory_count = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CEcon_GetInventoryItemsWithDescriptions_Response {
        static instance: CEcon_GetInventoryItemsWithDescriptions_Response = CEcon_GetInventoryItemsWithDescriptions_Response {
            assets: ::std::vec::Vec::new(),
            descriptions: ::std::vec::Vec::new(),
            missing_assets: ::std::vec::Vec::new(),
            asset_properties: ::std::vec::Vec::new(),
            more_items: ::std::option::Option::None,
            last_assetid: ::std::option::Option::None,
            total_inventory_count: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

impl<'a> ::std::default::Default for &'a CEcon_GetTradeOfferAccessToken_Request {
    fn default() -> &'a CEcon_GetTradeOfferAccessToken_Request {
        <CEcon_GetTradeOfferAccessToken_Request as ::steam_vent_proto_common::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 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 ::steam_vent_proto_common::protobuf::Message for CEcon_GetTradeOfferAccessToken_Request {
    const NAME: &'static str = "CEcon_GetTradeOfferAccessToken_Request";

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

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

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

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

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

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

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

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

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

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

impl<'a> ::std::default::Default for &'a CEcon_GetTradeOfferAccessToken_Response {
    fn default() -> &'a CEcon_GetTradeOfferAccessToken_Response {
        <CEcon_GetTradeOfferAccessToken_Response as ::steam_vent_proto_common::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 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 = ::std::option::Option::None;
    }

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_trade_offer_access_token(&mut self) -> &mut ::std::string::String {
        if self.trade_offer_access_token.is_none() {
            self.trade_offer_access_token = ::std::option::Option::Some(::std::string::String::new());
        }
        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 ::steam_vent_proto_common::protobuf::Message for CEcon_GetTradeOfferAccessToken_Response {
    const NAME: &'static str = "CEcon_GetTradeOfferAccessToken_Response";

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

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

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

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

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

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

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

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

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

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

impl<'a> ::std::default::Default for &'a CEcon_ClientGetItemShopOverlayAuthURL_Request {
    fn default() -> &'a CEcon_ClientGetItemShopOverlayAuthURL_Request {
        <CEcon_ClientGetItemShopOverlayAuthURL_Request as ::steam_vent_proto_common::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 return_url(&self) -> &str {
        match self.return_url.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_return_url(&mut self) -> &mut ::std::string::String {
        if self.return_url.is_none() {
            self.return_url = ::std::option::Option::Some(::std::string::String::new());
        }
        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 ::steam_vent_proto_common::protobuf::Message for CEcon_ClientGetItemShopOverlayAuthURL_Request {
    const NAME: &'static str = "CEcon_ClientGetItemShopOverlayAuthURL_Request";

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

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

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

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

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

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

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

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

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

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

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

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

    // optional string url = 1;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_url(&mut self) -> &mut ::std::string::String {
        if self.url.is_none() {
            self.url = ::std::option::Option::Some(::std::string::String::new());
        }
        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 ::steam_vent_proto_common::protobuf::Message for CEcon_ClientGetItemShopOverlayAuthURL_Response {
    const NAME: &'static str = "CEcon_ClientGetItemShopOverlayAuthURL_Response";

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

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

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

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

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

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

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

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

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

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

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

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

    // optional string language = 1;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_language(&mut self) -> &mut ::std::string::String {
        if self.language.is_none() {
            self.language = ::std::option::Option::Some(::std::string::String::new());
        }
        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 appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }

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

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

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

    // optional bool high_pri = 4;

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

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

    pub fn has_high_pri(&self) -> bool {
        self.high_pri.is_some()
    }

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.language.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(2, v)?;
        }
        for v in &self.classes {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        if let Some(v) = self.high_pri {
            os.write_bool(4, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

#[allow(unused_imports)]
use crate::steammessages_base::*;
#[allow(unused_imports)]
use crate::steammessages_unified_base_steamclient::*;
impl ::steam_vent_proto_common::RpcMessage
for CEcon_GetInventoryItemsWithDescriptions_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CEcon_Asset {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CEconItem_DescriptionLine {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CEconItem_Action {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CEconItem_Description {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CEconItem_Tag {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CEconItem_ClassIdentifiers {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CEconItem_ContainerProperties {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CEconItem_AssetProperty {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CEconItem_AssetProperties {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CEcon_GetInventoryItemsWithDescriptions_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CEcon_GetTradeOfferAccessToken_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CEcon_GetTradeOfferAccessToken_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CEcon_ClientGetItemShopOverlayAuthURL_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CEcon_ClientGetItemShopOverlayAuthURL_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CEcon_GetAssetClassInfo_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CEcon_GetAssetClassInfo_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
///
struct Econ {}
impl ::steam_vent_proto_common::RpcService for Econ {
    const SERVICE_NAME: &'static str = "Econ";
}
impl ::steam_vent_proto_common::RpcMethod
for CEcon_ClientGetItemShopOverlayAuthURL_Request {
    const METHOD_NAME: &'static str = "Econ.ClientGetItemShopOverlayAuthURL#1";
    type Response = CEcon_ClientGetItemShopOverlayAuthURL_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CEcon_GetAssetClassInfo_Request {
    const METHOD_NAME: &'static str = "Econ.GetAssetClassInfo#1";
    type Response = CEcon_GetAssetClassInfo_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CEcon_GetInventoryItemsWithDescriptions_Request {
    const METHOD_NAME: &'static str = "Econ.GetInventoryItemsWithDescriptions#1";
    type Response = CEcon_GetInventoryItemsWithDescriptions_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CEcon_GetTradeOfferAccessToken_Request {
    const METHOD_NAME: &'static str = "Econ.GetTradeOfferAccessToken#1";
    type Response = CEcon_GetTradeOfferAccessToken_Response;
}
