// 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_inventory.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:CInventory_GetInventory_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CInventory_GetInventory_Request {
    // message fields
    // @@protoc_insertion_point(field:CInventory_GetInventory_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CInventory_GetInventory_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CInventory_GetInventory_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl CInventory_GetInventory_Request {
    pub fn new() -> CInventory_GetInventory_Request {
        ::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 steamid = 2;

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_GetInventory_Request {
    const NAME: &'static str = "CInventory_GetInventory_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.steamid = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.steamid {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.steamid {
            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() -> CInventory_GetInventory_Request {
        CInventory_GetInventory_Request::new()
    }

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

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

// @@protoc_insertion_point(message:CInventory_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CInventory_Response {
    // message fields
    // @@protoc_insertion_point(field:CInventory_Response.etag)
    pub etag: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CInventory_Response.removeditemids)
    pub removeditemids: ::std::vec::Vec<u64>,
    // @@protoc_insertion_point(field:CInventory_Response.item_json)
    pub item_json: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CInventory_Response.itemdef_json)
    pub itemdef_json: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CInventory_Response.ticket)
    pub ticket: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CInventory_Response.replayed)
    pub replayed: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CInventory_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string etag = 1;

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

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

    pub fn has_etag(&self) -> bool {
        self.etag.is_some()
    }

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

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

    // optional string item_json = 3;

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

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

    pub fn has_item_json(&self) -> bool {
        self.item_json.is_some()
    }

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

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

    // optional string itemdef_json = 4;

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

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

    pub fn has_itemdef_json(&self) -> bool {
        self.itemdef_json.is_some()
    }

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

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

    // optional bytes ticket = 5;

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

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

    pub fn has_ticket(&self) -> bool {
        self.ticket.is_some()
    }

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

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

    // optional bool replayed = 6;

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

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

    pub fn has_replayed(&self) -> bool {
        self.replayed.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_Response {
    const NAME: &'static str = "CInventory_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.etag = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    is.read_repeated_packed_uint64_into(&mut self.removeditemids)?;
                },
                16 => {
                    self.removeditemids.push(is.read_uint64()?);
                },
                26 => {
                    self.item_json = ::std::option::Option::Some(is.read_string()?);
                },
                34 => {
                    self.itemdef_json = ::std::option::Option::Some(is.read_string()?);
                },
                42 => {
                    self.ticket = ::std::option::Option::Some(is.read_bytes()?);
                },
                48 => {
                    self.replayed = ::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.etag.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        for value in &self.removeditemids {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, *value);
        };
        if let Some(v) = self.item_json.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.itemdef_json.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.ticket.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(5, &v);
        }
        if let Some(v) = self.replayed {
            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.etag.as_ref() {
            os.write_string(1, v)?;
        }
        for v in &self.removeditemids {
            os.write_uint64(2, *v)?;
        };
        if let Some(v) = self.item_json.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.itemdef_json.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.ticket.as_ref() {
            os.write_bytes(5, v)?;
        }
        if let Some(v) = self.replayed {
            os.write_bool(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() -> CInventory_Response {
        CInventory_Response::new()
    }

    fn clear(&mut self) {
        self.etag = ::std::option::Option::None;
        self.removeditemids.clear();
        self.item_json = ::std::option::Option::None;
        self.itemdef_json = ::std::option::Option::None;
        self.ticket = ::std::option::Option::None;
        self.replayed = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CInventory_Response {
        static instance: CInventory_Response = CInventory_Response {
            etag: ::std::option::Option::None,
            removeditemids: ::std::vec::Vec::new(),
            item_json: ::std::option::Option::None,
            itemdef_json: ::std::option::Option::None,
            ticket: ::std::option::Option::None,
            replayed: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CInventory_ExchangeItem_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CInventory_ExchangeItem_Request {
    // message fields
    // @@protoc_insertion_point(field:CInventory_ExchangeItem_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CInventory_ExchangeItem_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CInventory_ExchangeItem_Request.materialsitemid)
    pub materialsitemid: ::std::vec::Vec<u64>,
    // @@protoc_insertion_point(field:CInventory_ExchangeItem_Request.materialsquantity)
    pub materialsquantity: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CInventory_ExchangeItem_Request.outputitemdefid)
    pub outputitemdefid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CInventory_ExchangeItem_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl CInventory_ExchangeItem_Request {
    pub fn new() -> CInventory_ExchangeItem_Request {
        ::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 steamid = 2;

    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 uint64 outputitemdefid = 5;

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

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

    pub fn has_outputitemdefid(&self) -> bool {
        self.outputitemdefid.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_ExchangeItem_Request {
    const NAME: &'static str = "CInventory_ExchangeItem_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.steamid = ::std::option::Option::Some(is.read_uint64()?);
                },
                26 => {
                    is.read_repeated_packed_uint64_into(&mut self.materialsitemid)?;
                },
                24 => {
                    self.materialsitemid.push(is.read_uint64()?);
                },
                34 => {
                    is.read_repeated_packed_uint32_into(&mut self.materialsquantity)?;
                },
                32 => {
                    self.materialsquantity.push(is.read_uint32()?);
                },
                40 => {
                    self.outputitemdefid = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.steamid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        for value in &self.materialsitemid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, *value);
        };
        for value in &self.materialsquantity {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, *value);
        };
        if let Some(v) = self.outputitemdefid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_uint64(2, v)?;
        }
        for v in &self.materialsitemid {
            os.write_uint64(3, *v)?;
        };
        for v in &self.materialsquantity {
            os.write_uint32(4, *v)?;
        };
        if let Some(v) = self.outputitemdefid {
            os.write_uint64(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() -> CInventory_ExchangeItem_Request {
        CInventory_ExchangeItem_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.steamid = ::std::option::Option::None;
        self.materialsitemid.clear();
        self.materialsquantity.clear();
        self.outputitemdefid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CInventory_ExchangeItem_Request {
        static instance: CInventory_ExchangeItem_Request = CInventory_ExchangeItem_Request {
            appid: ::std::option::Option::None,
            steamid: ::std::option::Option::None,
            materialsitemid: ::std::vec::Vec::new(),
            materialsquantity: ::std::vec::Vec::new(),
            outputitemdefid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

impl CInventory_GetEligiblePromoItemDefIDs_Request {
    pub fn new() -> CInventory_GetEligiblePromoItemDefIDs_Request {
        ::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 steamid = 2;

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_GetEligiblePromoItemDefIDs_Request {
    const NAME: &'static str = "CInventory_GetEligiblePromoItemDefIDs_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.steamid = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.steamid {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.steamid {
            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() -> CInventory_GetEligiblePromoItemDefIDs_Request {
        CInventory_GetEligiblePromoItemDefIDs_Request::new()
    }

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

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_GetEligiblePromoItemDefIDs_Response {
    const NAME: &'static str = "CInventory_GetEligiblePromoItemDefIDs_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 => {
                    is.read_repeated_packed_uint64_into(&mut self.itemdefids)?;
                },
                8 => {
                    self.itemdefids.push(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;
        for value in &self.itemdefids {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, *value);
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.itemdefids {
            os.write_uint64(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() -> CInventory_GetEligiblePromoItemDefIDs_Response {
        CInventory_GetEligiblePromoItemDefIDs_Response::new()
    }

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

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

// @@protoc_insertion_point(message:CInventory_AddItem_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CInventory_AddItem_Request {
    // message fields
    // @@protoc_insertion_point(field:CInventory_AddItem_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CInventory_AddItem_Request.itemdefid)
    pub itemdefid: ::std::vec::Vec<u64>,
    // @@protoc_insertion_point(field:CInventory_AddItem_Request.itempropsjson)
    pub itempropsjson: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CInventory_AddItem_Request.itemquantity)
    pub itemquantity: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:CInventory_AddItem_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CInventory_AddItem_Request.notify)
    pub notify: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CInventory_AddItem_Request.requestid)
    pub requestid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CInventory_AddItem_Request.trade_restriction)
    pub trade_restriction: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CInventory_AddItem_Request.is_purchase)
    pub is_purchase: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CInventory_AddItem_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl CInventory_AddItem_Request {
    pub fn new() -> CInventory_AddItem_Request {
        ::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 steamid = 4;

    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 bool notify = 5;

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

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

    pub fn has_notify(&self) -> bool {
        self.notify.is_some()
    }

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

    // optional uint64 requestid = 6;

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

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

    pub fn has_requestid(&self) -> bool {
        self.requestid.is_some()
    }

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

    // optional bool trade_restriction = 7;

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

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

    pub fn has_trade_restriction(&self) -> bool {
        self.trade_restriction.is_some()
    }

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

    // optional bool is_purchase = 8;

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

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

    pub fn has_is_purchase(&self) -> bool {
        self.is_purchase.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_AddItem_Request {
    const NAME: &'static str = "CInventory_AddItem_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                18 => {
                    is.read_repeated_packed_uint64_into(&mut self.itemdefid)?;
                },
                16 => {
                    self.itemdefid.push(is.read_uint64()?);
                },
                26 => {
                    self.itempropsjson.push(is.read_string()?);
                },
                74 => {
                    is.read_repeated_packed_uint32_into(&mut self.itemquantity)?;
                },
                72 => {
                    self.itemquantity.push(is.read_uint32()?);
                },
                32 => {
                    self.steamid = ::std::option::Option::Some(is.read_uint64()?);
                },
                40 => {
                    self.notify = ::std::option::Option::Some(is.read_bool()?);
                },
                48 => {
                    self.requestid = ::std::option::Option::Some(is.read_uint64()?);
                },
                56 => {
                    self.trade_restriction = ::std::option::Option::Some(is.read_bool()?);
                },
                64 => {
                    self.is_purchase = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        for value in &self.itemdefid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, *value);
        };
        for value in &self.itempropsjson {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &value);
        };
        for value in &self.itemquantity {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, *value);
        };
        if let Some(v) = self.steamid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(4, v);
        }
        if let Some(v) = self.notify {
            my_size += 1 + 1;
        }
        if let Some(v) = self.requestid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(6, v);
        }
        if let Some(v) = self.trade_restriction {
            my_size += 1 + 1;
        }
        if let Some(v) = self.is_purchase {
            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.appid {
            os.write_uint32(1, v)?;
        }
        for v in &self.itemdefid {
            os.write_uint64(2, *v)?;
        };
        for v in &self.itempropsjson {
            os.write_string(3, &v)?;
        };
        for v in &self.itemquantity {
            os.write_uint32(9, *v)?;
        };
        if let Some(v) = self.steamid {
            os.write_uint64(4, v)?;
        }
        if let Some(v) = self.notify {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.requestid {
            os.write_uint64(6, v)?;
        }
        if let Some(v) = self.trade_restriction {
            os.write_bool(7, v)?;
        }
        if let Some(v) = self.is_purchase {
            os.write_bool(8, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.itemdefid.clear();
        self.itempropsjson.clear();
        self.itemquantity.clear();
        self.steamid = ::std::option::Option::None;
        self.notify = ::std::option::Option::None;
        self.requestid = ::std::option::Option::None;
        self.trade_restriction = ::std::option::Option::None;
        self.is_purchase = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CInventory_AddItem_Request {
        static instance: CInventory_AddItem_Request = CInventory_AddItem_Request {
            appid: ::std::option::Option::None,
            itemdefid: ::std::vec::Vec::new(),
            itempropsjson: ::std::vec::Vec::new(),
            itemquantity: ::std::vec::Vec::new(),
            steamid: ::std::option::Option::None,
            notify: ::std::option::Option::None,
            requestid: ::std::option::Option::None,
            trade_restriction: ::std::option::Option::None,
            is_purchase: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CInventory_ModifyItems_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CInventory_ModifyItems_Request {
    // message fields
    // @@protoc_insertion_point(field:CInventory_ModifyItems_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CInventory_ModifyItems_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CInventory_ModifyItems_Request.updates)
    pub updates: ::std::vec::Vec<cinventory_modify_items_request::ItemPropertyUpdate>,
    // @@protoc_insertion_point(field:CInventory_ModifyItems_Request.timestamp)
    pub timestamp: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CInventory_ModifyItems_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl CInventory_ModifyItems_Request {
    pub fn new() -> CInventory_ModifyItems_Request {
        ::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 steamid = 2;

    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 timestamp = 4;

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

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

    pub fn has_timestamp(&self) -> bool {
        self.timestamp.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_ModifyItems_Request {
    const NAME: &'static str = "CInventory_ModifyItems_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.steamid = ::std::option::Option::Some(is.read_uint64()?);
                },
                26 => {
                    self.updates.push(is.read_message()?);
                },
                32 => {
                    self.timestamp = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.steamid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        for value in &self.updates {
            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.timestamp {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_uint64(2, v)?;
        }
        for v in &self.updates {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        if let Some(v) = self.timestamp {
            os.write_uint32(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() -> CInventory_ModifyItems_Request {
        CInventory_ModifyItems_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.steamid = ::std::option::Option::None;
        self.updates.clear();
        self.timestamp = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CInventory_ModifyItems_Request {
        static instance: CInventory_ModifyItems_Request = CInventory_ModifyItems_Request {
            appid: ::std::option::Option::None,
            steamid: ::std::option::Option::None,
            updates: ::std::vec::Vec::new(),
            timestamp: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CInventory_ModifyItems_Request`
pub mod cinventory_modify_items_request {
    // @@protoc_insertion_point(message:CInventory_ModifyItems_Request.ItemPropertyUpdate)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct ItemPropertyUpdate {
        // message fields
        // @@protoc_insertion_point(field:CInventory_ModifyItems_Request.ItemPropertyUpdate.itemid)
        pub itemid: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CInventory_ModifyItems_Request.ItemPropertyUpdate.remove_property)
        pub remove_property: ::std::option::Option<bool>,
        // @@protoc_insertion_point(field:CInventory_ModifyItems_Request.ItemPropertyUpdate.property_name)
        pub property_name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CInventory_ModifyItems_Request.ItemPropertyUpdate.property_value_bool)
        pub property_value_bool: ::std::option::Option<bool>,
        // @@protoc_insertion_point(field:CInventory_ModifyItems_Request.ItemPropertyUpdate.property_value_int)
        pub property_value_int: ::std::option::Option<i64>,
        // @@protoc_insertion_point(field:CInventory_ModifyItems_Request.ItemPropertyUpdate.property_value_string)
        pub property_value_string: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CInventory_ModifyItems_Request.ItemPropertyUpdate.property_value_float)
        pub property_value_float: ::std::option::Option<f32>,
        // special fields
        // @@protoc_insertion_point(special_field:CInventory_ModifyItems_Request.ItemPropertyUpdate.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional uint64 itemid = 1;

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

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

        pub fn has_itemid(&self) -> bool {
            self.itemid.is_some()
        }

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

        // optional bool remove_property = 2;

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

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

        pub fn has_remove_property(&self) -> bool {
            self.remove_property.is_some()
        }

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

        // optional string property_name = 3;

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

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

        pub fn has_property_name(&self) -> bool {
            self.property_name.is_some()
        }

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

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

        // optional bool property_value_bool = 4;

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

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

        pub fn has_property_value_bool(&self) -> bool {
            self.property_value_bool.is_some()
        }

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

        // optional int64 property_value_int = 5;

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

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

        pub fn has_property_value_int(&self) -> bool {
            self.property_value_int.is_some()
        }

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

        // optional string property_value_string = 6;

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

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

        pub fn has_property_value_string(&self) -> bool {
            self.property_value_string.is_some()
        }

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

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

        // optional float property_value_float = 7;

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

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

        pub fn has_property_value_float(&self) -> bool {
            self.property_value_float.is_some()
        }

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

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

        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.itemid = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    16 => {
                        self.remove_property = ::std::option::Option::Some(is.read_bool()?);
                    },
                    26 => {
                        self.property_name = ::std::option::Option::Some(is.read_string()?);
                    },
                    32 => {
                        self.property_value_bool = ::std::option::Option::Some(is.read_bool()?);
                    },
                    40 => {
                        self.property_value_int = ::std::option::Option::Some(is.read_int64()?);
                    },
                    50 => {
                        self.property_value_string = ::std::option::Option::Some(is.read_string()?);
                    },
                    61 => {
                        self.property_value_float = ::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.itemid {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
            }
            if let Some(v) = self.remove_property {
                my_size += 1 + 1;
            }
            if let Some(v) = self.property_name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
            }
            if let Some(v) = self.property_value_bool {
                my_size += 1 + 1;
            }
            if let Some(v) = self.property_value_int {
                my_size += ::steam_vent_proto_common::protobuf::rt::int64_size(5, v);
            }
            if let Some(v) = self.property_value_string.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
            }
            if let Some(v) = self.property_value_float {
                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.itemid {
                os.write_uint64(1, v)?;
            }
            if let Some(v) = self.remove_property {
                os.write_bool(2, v)?;
            }
            if let Some(v) = self.property_name.as_ref() {
                os.write_string(3, v)?;
            }
            if let Some(v) = self.property_value_bool {
                os.write_bool(4, v)?;
            }
            if let Some(v) = self.property_value_int {
                os.write_int64(5, v)?;
            }
            if let Some(v) = self.property_value_string.as_ref() {
                os.write_string(6, v)?;
            }
            if let Some(v) = self.property_value_float {
                os.write_float(7, 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() -> ItemPropertyUpdate {
            ItemPropertyUpdate::new()
        }

        fn clear(&mut self) {
            self.itemid = ::std::option::Option::None;
            self.remove_property = ::std::option::Option::None;
            self.property_name = ::std::option::Option::None;
            self.property_value_bool = ::std::option::Option::None;
            self.property_value_int = ::std::option::Option::None;
            self.property_value_string = ::std::option::Option::None;
            self.property_value_float = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static ItemPropertyUpdate {
            static instance: ItemPropertyUpdate = ItemPropertyUpdate {
                itemid: ::std::option::Option::None,
                remove_property: ::std::option::Option::None,
                property_name: ::std::option::Option::None,
                property_value_bool: ::std::option::Option::None,
                property_value_int: ::std::option::Option::None,
                property_value_string: ::std::option::Option::None,
                property_value_float: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

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

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

impl CInventory_ConsumePlaytime_Request {
    pub fn new() -> CInventory_ConsumePlaytime_Request {
        ::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 itemdefid = 2;

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

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

    pub fn has_itemdefid(&self) -> bool {
        self.itemdefid.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_ConsumePlaytime_Request {
    const NAME: &'static str = "CInventory_ConsumePlaytime_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.itemdefid = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.itemdefid {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.itemdefid {
            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() -> CInventory_ConsumePlaytime_Request {
        CInventory_ConsumePlaytime_Request::new()
    }

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

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

// @@protoc_insertion_point(message:CInventory_ConsumeItem_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CInventory_ConsumeItem_Request {
    // message fields
    // @@protoc_insertion_point(field:CInventory_ConsumeItem_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CInventory_ConsumeItem_Request.itemid)
    pub itemid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CInventory_ConsumeItem_Request.quantity)
    pub quantity: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CInventory_ConsumeItem_Request.timestamp)
    pub timestamp: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CInventory_ConsumeItem_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CInventory_ConsumeItem_Request.requestid)
    pub requestid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CInventory_ConsumeItem_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl CInventory_ConsumeItem_Request {
    pub fn new() -> CInventory_ConsumeItem_Request {
        ::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 itemid = 2;

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

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

    pub fn has_itemid(&self) -> bool {
        self.itemid.is_some()
    }

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

    // optional uint32 quantity = 3;

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

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

    pub fn has_quantity(&self) -> bool {
        self.quantity.is_some()
    }

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

    // optional string timestamp = 4;

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

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

    pub fn has_timestamp(&self) -> bool {
        self.timestamp.is_some()
    }

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

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

    // optional uint64 steamid = 5;

    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 uint64 requestid = 6;

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

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

    pub fn has_requestid(&self) -> bool {
        self.requestid.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_ConsumeItem_Request {
    const NAME: &'static str = "CInventory_ConsumeItem_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.itemid = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.quantity = ::std::option::Option::Some(is.read_uint32()?);
                },
                34 => {
                    self.timestamp = ::std::option::Option::Some(is.read_string()?);
                },
                40 => {
                    self.steamid = ::std::option::Option::Some(is.read_uint64()?);
                },
                48 => {
                    self.requestid = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.itemid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.quantity {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.timestamp.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.steamid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(5, v);
        }
        if let Some(v) = self.requestid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.itemid {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.quantity {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.timestamp.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_uint64(5, v)?;
        }
        if let Some(v) = self.requestid {
            os.write_uint64(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() -> CInventory_ConsumeItem_Request {
        CInventory_ConsumeItem_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.itemid = ::std::option::Option::None;
        self.quantity = ::std::option::Option::None;
        self.timestamp = ::std::option::Option::None;
        self.steamid = ::std::option::Option::None;
        self.requestid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CInventory_ConsumeItem_Request {
        static instance: CInventory_ConsumeItem_Request = CInventory_ConsumeItem_Request {
            appid: ::std::option::Option::None,
            itemid: ::std::option::Option::None,
            quantity: ::std::option::Option::None,
            timestamp: ::std::option::Option::None,
            steamid: ::std::option::Option::None,
            requestid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

impl CInventory_DevSetNextDrop_Request {
    pub fn new() -> CInventory_DevSetNextDrop_Request {
        ::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 itemdefid = 2;

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

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

    pub fn has_itemdefid(&self) -> bool {
        self.itemdefid.is_some()
    }

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

    // optional string droptime = 3;

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

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

    pub fn has_droptime(&self) -> bool {
        self.droptime.is_some()
    }

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

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_DevSetNextDrop_Request {
    const NAME: &'static str = "CInventory_DevSetNextDrop_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.itemdefid = ::std::option::Option::Some(is.read_uint64()?);
                },
                26 => {
                    self.droptime = ::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.itemdefid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.droptime.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.itemdefid {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.droptime.as_ref() {
            os.write_string(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() -> CInventory_DevSetNextDrop_Request {
        CInventory_DevSetNextDrop_Request::new()
    }

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

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

// @@protoc_insertion_point(message:CInventory_SplitItemStack_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CInventory_SplitItemStack_Request {
    // message fields
    // @@protoc_insertion_point(field:CInventory_SplitItemStack_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CInventory_SplitItemStack_Request.itemid)
    pub itemid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CInventory_SplitItemStack_Request.quantity)
    pub quantity: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CInventory_SplitItemStack_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CInventory_SplitItemStack_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl CInventory_SplitItemStack_Request {
    pub fn new() -> CInventory_SplitItemStack_Request {
        ::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 itemid = 2;

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

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

    pub fn has_itemid(&self) -> bool {
        self.itemid.is_some()
    }

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

    // optional uint32 quantity = 3;

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

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

    pub fn has_quantity(&self) -> bool {
        self.quantity.is_some()
    }

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

    // optional uint64 steamid = 5;

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_SplitItemStack_Request {
    const NAME: &'static str = "CInventory_SplitItemStack_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.itemid = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.quantity = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.steamid = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.itemid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.quantity {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.steamid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.itemid {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.quantity {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_uint64(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() -> CInventory_SplitItemStack_Request {
        CInventory_SplitItemStack_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.itemid = ::std::option::Option::None;
        self.quantity = ::std::option::Option::None;
        self.steamid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CInventory_SplitItemStack_Request {
        static instance: CInventory_SplitItemStack_Request = CInventory_SplitItemStack_Request {
            appid: ::std::option::Option::None,
            itemid: ::std::option::Option::None,
            quantity: ::std::option::Option::None,
            steamid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CInventory_CombineItemStacks_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CInventory_CombineItemStacks_Request {
    // message fields
    // @@protoc_insertion_point(field:CInventory_CombineItemStacks_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CInventory_CombineItemStacks_Request.fromitemid)
    pub fromitemid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CInventory_CombineItemStacks_Request.destitemid)
    pub destitemid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CInventory_CombineItemStacks_Request.quantity)
    pub quantity: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CInventory_CombineItemStacks_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CInventory_CombineItemStacks_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl CInventory_CombineItemStacks_Request {
    pub fn new() -> CInventory_CombineItemStacks_Request {
        ::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 fromitemid = 2;

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

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

    pub fn has_fromitemid(&self) -> bool {
        self.fromitemid.is_some()
    }

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

    // optional uint64 destitemid = 3;

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

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

    pub fn has_destitemid(&self) -> bool {
        self.destitemid.is_some()
    }

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

    // optional uint32 quantity = 4;

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

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

    pub fn has_quantity(&self) -> bool {
        self.quantity.is_some()
    }

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

    // optional fixed64 steamid = 7;

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_CombineItemStacks_Request {
    const NAME: &'static str = "CInventory_CombineItemStacks_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.fromitemid = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.destitemid = ::std::option::Option::Some(is.read_uint64()?);
                },
                32 => {
                    self.quantity = ::std::option::Option::Some(is.read_uint32()?);
                },
                57 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                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.fromitemid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.destitemid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
        }
        if let Some(v) = self.quantity {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.steamid {
            my_size += 1 + 8;
        }
        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.fromitemid {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.destitemid {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.quantity {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_fixed64(7, 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() -> CInventory_CombineItemStacks_Request {
        CInventory_CombineItemStacks_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.fromitemid = ::std::option::Option::None;
        self.destitemid = ::std::option::Option::None;
        self.quantity = ::std::option::Option::None;
        self.steamid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CInventory_CombineItemStacks_Request {
        static instance: CInventory_CombineItemStacks_Request = CInventory_CombineItemStacks_Request {
            appid: ::std::option::Option::None,
            fromitemid: ::std::option::Option::None,
            destitemid: ::std::option::Option::None,
            quantity: ::std::option::Option::None,
            steamid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

impl CInventory_GetItemDefMeta_Request {
    pub fn new() -> CInventory_GetItemDefMeta_Request {
        ::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);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CInventory_GetItemDefMeta_Request {
    const NAME: &'static str = "CInventory_GetItemDefMeta_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_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.appid {
            os.write_uint32(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() -> CInventory_GetItemDefMeta_Request {
        CInventory_GetItemDefMeta_Request::new()
    }

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

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

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

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

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

    // optional uint32 modified = 1;

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

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

    pub fn has_modified(&self) -> bool {
        self.modified.is_some()
    }

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

    // optional string digest = 2;

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

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

    pub fn has_digest(&self) -> bool {
        self.digest.is_some()
    }

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

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_GetItemDefMeta_Response {
    const NAME: &'static str = "CInventory_GetItemDefMeta_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 {
                8 => {
                    self.modified = ::std::option::Option::Some(is.read_uint32()?);
                },
                18 => {
                    self.digest = ::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.modified {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.digest.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.modified {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.digest.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() -> CInventory_GetItemDefMeta_Response {
        CInventory_GetItemDefMeta_Response::new()
    }

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

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_GetUserPurchaseInfo_Request {
    const NAME: &'static str = "CInventory_GetUserPurchaseInfo_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 {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional int32 ecurrency = 1;

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

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

    pub fn has_ecurrency(&self) -> bool {
        self.ecurrency.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_GetUserPurchaseInfo_Response {
    const NAME: &'static str = "CInventory_GetUserPurchaseInfo_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 {
                8 => {
                    self.ecurrency = ::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.ecurrency {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_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.ecurrency {
            os.write_int32(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() -> CInventory_GetUserPurchaseInfo_Response {
        CInventory_GetUserPurchaseInfo_Response::new()
    }

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

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

// @@protoc_insertion_point(message:CInventory_PurchaseInit_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CInventory_PurchaseInit_Request {
    // message fields
    // @@protoc_insertion_point(field:CInventory_PurchaseInit_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CInventory_PurchaseInit_Request.language)
    pub language: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CInventory_PurchaseInit_Request.line_items)
    pub line_items: ::std::vec::Vec<cinventory_purchase_init_request::LineItem>,
    // special fields
    // @@protoc_insertion_point(special_field:CInventory_PurchaseInit_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl CInventory_PurchaseInit_Request {
    pub fn new() -> CInventory_PurchaseInit_Request {
        ::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 int32 language = 2;

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

    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: i32) {
        self.language = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CInventory_PurchaseInit_Request {
    const NAME: &'static str = "CInventory_PurchaseInit_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.language = ::std::option::Option::Some(is.read_int32()?);
                },
                26 => {
                    self.line_items.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.language {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
        }
        for value in &self.line_items {
            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.language {
            os.write_int32(2, v)?;
        }
        for v in &self.line_items {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

/// Nested message and enums of message `CInventory_PurchaseInit_Request`
pub mod cinventory_purchase_init_request {
    // @@protoc_insertion_point(message:CInventory_PurchaseInit_Request.LineItem)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct LineItem {
        // message fields
        // @@protoc_insertion_point(field:CInventory_PurchaseInit_Request.LineItem.itemdefid)
        pub itemdefid: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CInventory_PurchaseInit_Request.LineItem.quantity)
        pub quantity: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:CInventory_PurchaseInit_Request.LineItem.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional uint64 itemdefid = 1;

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

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

        pub fn has_itemdefid(&self) -> bool {
            self.itemdefid.is_some()
        }

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

        // optional uint32 quantity = 2;

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

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

        pub fn has_quantity(&self) -> bool {
            self.quantity.is_some()
        }

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

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

        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.itemdefid = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    16 => {
                        self.quantity = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

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

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

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

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

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

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

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

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

    // optional uint64 orderid = 1;

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

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

    pub fn has_orderid(&self) -> bool {
        self.orderid.is_some()
    }

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

    // optional uint64 transid = 2;

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

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

    pub fn has_transid(&self) -> bool {
        self.transid.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_PurchaseInit_Response {
    const NAME: &'static str = "CInventory_PurchaseInit_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 {
                8 => {
                    self.orderid = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.transid = ::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.orderid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.transid {
            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.orderid {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.transid {
            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() -> CInventory_PurchaseInit_Response {
        CInventory_PurchaseInit_Response::new()
    }

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

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

// @@protoc_insertion_point(message:CInventory_PurchaseFinalize_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CInventory_PurchaseFinalize_Request {
    // message fields
    // @@protoc_insertion_point(field:CInventory_PurchaseFinalize_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CInventory_PurchaseFinalize_Request.language)
    pub language: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CInventory_PurchaseFinalize_Request.orderid)
    pub orderid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CInventory_PurchaseFinalize_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

impl CInventory_PurchaseFinalize_Request {
    pub fn new() -> CInventory_PurchaseFinalize_Request {
        ::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 int32 language = 2;

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

    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: i32) {
        self.language = ::std::option::Option::Some(v);
    }

    // optional uint64 orderid = 3;

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

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

    pub fn has_orderid(&self) -> bool {
        self.orderid.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_PurchaseFinalize_Request {
    const NAME: &'static str = "CInventory_PurchaseFinalize_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.language = ::std::option::Option::Some(is.read_int32()?);
                },
                24 => {
                    self.orderid = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.language {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
        }
        if let Some(v) = self.orderid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.language {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.orderid {
            os.write_uint64(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() -> CInventory_PurchaseFinalize_Request {
        CInventory_PurchaseFinalize_Request::new()
    }

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

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

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

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

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

    // optional uint64 itemdefid = 1;

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

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

    pub fn has_itemdefid(&self) -> bool {
        self.itemdefid.is_some()
    }

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

    // optional fixed64 itemid = 2;

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

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

    pub fn has_itemid(&self) -> bool {
        self.itemid.is_some()
    }

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

    // optional string tags = 3;

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

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

    pub fn has_tags(&self) -> bool {
        self.tags.is_some()
    }

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

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

impl ::steam_vent_proto_common::protobuf::Message for CInventory_InspectItem_Request {
    const NAME: &'static str = "CInventory_InspectItem_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.itemdefid = ::std::option::Option::Some(is.read_uint64()?);
                },
                17 => {
                    self.itemid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                26 => {
                    self.tags = ::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.itemdefid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.itemid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.tags.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.itemdefid {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.itemid {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.tags.as_ref() {
            os.write_string(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() -> CInventory_InspectItem_Request {
        CInventory_InspectItem_Request::new()
    }

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

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

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

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

impl CInventoryClient_NewItems_Notification {
    pub fn new() -> CInventoryClient_NewItems_Notification {
        ::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);
    }
}

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

    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 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.inventory_response)?;
                },
                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.inventory_response.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.inventory_response.as_ref() {
            ::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() -> CInventoryClient_NewItems_Notification {
        CInventoryClient_NewItems_Notification::new()
    }

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

    fn default_instance() -> &'static CInventoryClient_NewItems_Notification {
        static instance: CInventoryClient_NewItems_Notification = CInventoryClient_NewItems_Notification {
            appid: ::std::option::Option::None,
            inventory_response: ::steam_vent_proto_common::protobuf::MessageField::none(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}


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

#[allow(unused_imports)]
use crate::steammessages_base::*;
#[allow(unused_imports)]
use crate::steammessages_unified_base_steamclient::*;
impl ::steam_vent_proto_common::RpcMessage for CInventory_GetInventory_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 CInventory_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 CInventory_ExchangeItem_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 CInventory_GetEligiblePromoItemDefIDs_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 CInventory_GetEligiblePromoItemDefIDs_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 CInventory_AddItem_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 CInventory_ModifyItems_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 CInventory_ConsumePlaytime_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 CInventory_ConsumeItem_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 CInventory_DevSetNextDrop_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 CInventory_SplitItemStack_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 CInventory_CombineItemStacks_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 CInventory_GetItemDefMeta_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 CInventory_GetItemDefMeta_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 CInventory_GetUserPurchaseInfo_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 CInventory_GetUserPurchaseInfo_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 CInventory_PurchaseInit_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 CInventory_PurchaseInit_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 CInventory_PurchaseFinalize_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 CInventory_InspectItem_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 CInventoryClient_NewItems_Notification {
    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 Inventory {}
impl ::steam_vent_proto_common::RpcService for Inventory {
    const SERVICE_NAME: &'static str = "Inventory";
}
///
struct InventoryClient {}
impl ::steam_vent_proto_common::RpcService for InventoryClient {
    const SERVICE_NAME: &'static str = "InventoryClient";
}
impl ::steam_vent_proto_common::RpcMethod for CInventoryClient_NewItems_Notification {
    const METHOD_NAME: &'static str = "InventoryClient.NotifyNewItems#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CInventory_AddItem_Request {
    const METHOD_NAME: &'static str = "Inventory.AddPromoItem#1";
    type Response = CInventory_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CInventory_CombineItemStacks_Request {
    const METHOD_NAME: &'static str = "Inventory.CombineItemStacks#1";
    type Response = CInventory_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CInventory_ConsumeItem_Request {
    const METHOD_NAME: &'static str = "Inventory.ConsumeItem#1";
    type Response = CInventory_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CInventory_ConsumePlaytime_Request {
    const METHOD_NAME: &'static str = "Inventory.ConsumePlaytime#1";
    type Response = CInventory_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CInventory_DevSetNextDrop_Request {
    const METHOD_NAME: &'static str = "Inventory.DevSetNextDrop#1";
    type Response = CInventory_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CInventory_ExchangeItem_Request {
    const METHOD_NAME: &'static str = "Inventory.ExchangeItem#1";
    type Response = CInventory_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CInventory_GetEligiblePromoItemDefIDs_Request {
    const METHOD_NAME: &'static str = "Inventory.GetEligiblePromoItemDefIDs#1";
    type Response = CInventory_GetEligiblePromoItemDefIDs_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CInventory_GetInventory_Request {
    const METHOD_NAME: &'static str = "Inventory.GetInventory#1";
    type Response = CInventory_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CInventory_GetItemDefMeta_Request {
    const METHOD_NAME: &'static str = "Inventory.GetItemDefMeta#1";
    type Response = CInventory_GetItemDefMeta_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CInventory_GetUserPurchaseInfo_Request {
    const METHOD_NAME: &'static str = "Inventory.GetUserPurchaseInfo#1";
    type Response = CInventory_GetUserPurchaseInfo_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CInventory_InspectItem_Request {
    const METHOD_NAME: &'static str = "Inventory.InspectItem#1";
    type Response = CInventory_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CInventory_ModifyItems_Request {
    const METHOD_NAME: &'static str = "Inventory.SafeModifyItems#1";
    type Response = CInventory_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CInventory_PurchaseFinalize_Request {
    const METHOD_NAME: &'static str = "Inventory.PurchaseFinalize#1";
    type Response = CInventory_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CInventory_PurchaseInit_Request {
    const METHOD_NAME: &'static str = "Inventory.PurchaseInit#1";
    type Response = CInventory_PurchaseInit_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CInventory_SplitItemStack_Request {
    const METHOD_NAME: &'static str = "Inventory.SplitItemStack#1";
    type Response = CInventory_Response;
}
