// 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_site_license.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:CSiteManagerClient_IncomingClient_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSiteManagerClient_IncomingClient_Request {
    // message fields
    // @@protoc_insertion_point(field:CSiteManagerClient_IncomingClient_Request.site_instanceid)
    pub site_instanceid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CSiteManagerClient_IncomingClient_Request.client_steamid)
    pub client_steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CSiteManagerClient_IncomingClient_Request.client_local_ip)
    pub client_local_ip: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CSiteManagerClient_IncomingClient_Request.connection_key)
    pub connection_key: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:CSiteManagerClient_IncomingClient_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed64 site_instanceid = 1;

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

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

    pub fn has_site_instanceid(&self) -> bool {
        self.site_instanceid.is_some()
    }

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

    // optional fixed64 client_steamid = 2;

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

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

    pub fn has_client_steamid(&self) -> bool {
        self.client_steamid.is_some()
    }

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

    // optional fixed32 client_local_ip = 3;

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

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

    pub fn has_client_local_ip(&self) -> bool {
        self.client_local_ip.is_some()
    }

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

    // optional bytes connection_key = 4;

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

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

    pub fn has_connection_key(&self) -> bool {
        self.connection_key.is_some()
    }

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                9 => {
                    self.site_instanceid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                17 => {
                    self.client_steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                29 => {
                    self.client_local_ip = ::std::option::Option::Some(is.read_fixed32()?);
                },
                34 => {
                    self.connection_key = ::std::option::Option::Some(is.read_bytes()?);
                },
                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.site_instanceid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.client_steamid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.client_local_ip {
            my_size += 1 + 4;
        }
        if let Some(v) = self.connection_key.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_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.site_instanceid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.client_steamid {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.client_local_ip {
            os.write_fixed32(3, v)?;
        }
        if let Some(v) = self.connection_key.as_ref() {
            os.write_bytes(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() -> CSiteManagerClient_IncomingClient_Request {
        CSiteManagerClient_IncomingClient_Request::new()
    }

    fn clear(&mut self) {
        self.site_instanceid = ::std::option::Option::None;
        self.client_steamid = ::std::option::Option::None;
        self.client_local_ip = ::std::option::Option::None;
        self.connection_key = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSiteManagerClient_IncomingClient_Request {
        static instance: CSiteManagerClient_IncomingClient_Request = CSiteManagerClient_IncomingClient_Request {
            site_instanceid: ::std::option::Option::None,
            client_steamid: ::std::option::Option::None,
            client_local_ip: ::std::option::Option::None,
            connection_key: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for CSiteManagerClient_IncomingClient_Response {
    const NAME: &'static str = "CSiteManagerClient_IncomingClient_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 {
                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() -> CSiteManagerClient_IncomingClient_Response {
        CSiteManagerClient_IncomingClient_Response::new()
    }

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

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

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

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

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

    // optional uint32 eresult = 2;

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

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

    pub fn has_eresult(&self) -> bool {
        self.eresult.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CSiteLicense_ClientSeatCheckout_Notification {
    const NAME: &'static str = "CSiteLicense_ClientSeatCheckout_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()?);
                },
                16 => {
                    self.eresult = ::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.eresult {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.eresult {
            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() -> CSiteLicense_ClientSeatCheckout_Notification {
        CSiteLicense_ClientSeatCheckout_Notification::new()
    }

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

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

// @@protoc_insertion_point(message:CSiteManagerClient_TrackedPayments_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CSiteManagerClient_TrackedPayments_Notification {
    // message fields
    // @@protoc_insertion_point(field:CSiteManagerClient_TrackedPayments_Notification.site_id)
    pub site_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CSiteManagerClient_TrackedPayments_Notification.payments)
    pub payments: ::std::vec::Vec<csite_manager_client_tracked_payments_notification::Payment>,
    // special fields
    // @@protoc_insertion_point(special_field:CSiteManagerClient_TrackedPayments_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed64 site_id = 1;

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

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

    pub fn has_site_id(&self) -> bool {
        self.site_id.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CSiteManagerClient_TrackedPayments_Notification {
    const NAME: &'static str = "CSiteManagerClient_TrackedPayments_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 {
                9 => {
                    self.site_id = ::std::option::Option::Some(is.read_fixed64()?);
                },
                18 => {
                    self.payments.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.site_id {
            my_size += 1 + 8;
        }
        for value in &self.payments {
            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.site_id {
            os.write_fixed64(1, v)?;
        }
        for v in &self.payments {
            ::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() -> CSiteManagerClient_TrackedPayments_Notification {
        CSiteManagerClient_TrackedPayments_Notification::new()
    }

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

    fn default_instance() -> &'static CSiteManagerClient_TrackedPayments_Notification {
        static instance: CSiteManagerClient_TrackedPayments_Notification = CSiteManagerClient_TrackedPayments_Notification {
            site_id: ::std::option::Option::None,
            payments: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CSiteManagerClient_TrackedPayments_Notification`
pub mod csite_manager_client_tracked_payments_notification {
    // @@protoc_insertion_point(message:CSiteManagerClient_TrackedPayments_Notification.Payment)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Payment {
        // message fields
        // @@protoc_insertion_point(field:CSiteManagerClient_TrackedPayments_Notification.Payment.transid)
        pub transid: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CSiteManagerClient_TrackedPayments_Notification.Payment.steamid)
        pub steamid: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CSiteManagerClient_TrackedPayments_Notification.Payment.amount)
        pub amount: ::std::option::Option<i64>,
        // @@protoc_insertion_point(field:CSiteManagerClient_TrackedPayments_Notification.Payment.ecurrency)
        pub ecurrency: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:CSiteManagerClient_TrackedPayments_Notification.Payment.time_created)
        pub time_created: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CSiteManagerClient_TrackedPayments_Notification.Payment.purchase_status)
        pub purchase_status: ::std::option::Option<i32>,
        // @@protoc_insertion_point(field:CSiteManagerClient_TrackedPayments_Notification.Payment.machine_name)
        pub machine_name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CSiteManagerClient_TrackedPayments_Notification.Payment.persona_name)
        pub persona_name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CSiteManagerClient_TrackedPayments_Notification.Payment.profile_url)
        pub profile_url: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CSiteManagerClient_TrackedPayments_Notification.Payment.avatar_url)
        pub avatar_url: ::std::option::Option<::std::string::String>,
        // special fields
        // @@protoc_insertion_point(special_field:CSiteManagerClient_TrackedPayments_Notification.Payment.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional uint64 transid = 1;

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

        // 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 int64 amount = 3;

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

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

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

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

        // optional uint32 ecurrency = 4;

        pub fn ecurrency(&self) -> u32 {
            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: u32) {
            self.ecurrency = ::std::option::Option::Some(v);
        }

        // optional int32 time_created = 5;

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

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

        pub fn has_time_created(&self) -> bool {
            self.time_created.is_some()
        }

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

        // optional int32 purchase_status = 6;

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

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

        pub fn has_purchase_status(&self) -> bool {
            self.purchase_status.is_some()
        }

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

        // optional string machine_name = 7;

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

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

        pub fn has_machine_name(&self) -> bool {
            self.machine_name.is_some()
        }

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

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

        // optional string persona_name = 8;

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

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

        pub fn has_persona_name(&self) -> bool {
            self.persona_name.is_some()
        }

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

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

        // optional string profile_url = 9;

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

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

        pub fn has_profile_url(&self) -> bool {
            self.profile_url.is_some()
        }

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

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

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

        // optional string avatar_url = 10;

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

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

        pub fn has_avatar_url(&self) -> bool {
            self.avatar_url.is_some()
        }

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

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

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

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

        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.transid = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    16 => {
                        self.steamid = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    24 => {
                        self.amount = ::std::option::Option::Some(is.read_int64()?);
                    },
                    32 => {
                        self.ecurrency = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    40 => {
                        self.time_created = ::std::option::Option::Some(is.read_int32()?);
                    },
                    48 => {
                        self.purchase_status = ::std::option::Option::Some(is.read_int32()?);
                    },
                    58 => {
                        self.machine_name = ::std::option::Option::Some(is.read_string()?);
                    },
                    66 => {
                        self.persona_name = ::std::option::Option::Some(is.read_string()?);
                    },
                    74 => {
                        self.profile_url = ::std::option::Option::Some(is.read_string()?);
                    },
                    82 => {
                        self.avatar_url = ::std::option::Option::Some(is.read_string()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if let Some(v) = self.transid {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
            }
            if let Some(v) = self.steamid {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
            }
            if let Some(v) = self.amount {
                my_size += ::steam_vent_proto_common::protobuf::rt::int64_size(3, v);
            }
            if let Some(v) = self.ecurrency {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
            }
            if let Some(v) = self.time_created {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v);
            }
            if let Some(v) = self.purchase_status {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(6, v);
            }
            if let Some(v) = self.machine_name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
            }
            if let Some(v) = self.persona_name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(8, &v);
            }
            if let Some(v) = self.profile_url.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &v);
            }
            if let Some(v) = self.avatar_url.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(10, &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.transid {
                os.write_uint64(1, v)?;
            }
            if let Some(v) = self.steamid {
                os.write_uint64(2, v)?;
            }
            if let Some(v) = self.amount {
                os.write_int64(3, v)?;
            }
            if let Some(v) = self.ecurrency {
                os.write_uint32(4, v)?;
            }
            if let Some(v) = self.time_created {
                os.write_int32(5, v)?;
            }
            if let Some(v) = self.purchase_status {
                os.write_int32(6, v)?;
            }
            if let Some(v) = self.machine_name.as_ref() {
                os.write_string(7, v)?;
            }
            if let Some(v) = self.persona_name.as_ref() {
                os.write_string(8, v)?;
            }
            if let Some(v) = self.profile_url.as_ref() {
                os.write_string(9, v)?;
            }
            if let Some(v) = self.avatar_url.as_ref() {
                os.write_string(10, 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() -> Payment {
            Payment::new()
        }

        fn clear(&mut self) {
            self.transid = ::std::option::Option::None;
            self.steamid = ::std::option::Option::None;
            self.amount = ::std::option::Option::None;
            self.ecurrency = ::std::option::Option::None;
            self.time_created = ::std::option::Option::None;
            self.purchase_status = ::std::option::Option::None;
            self.machine_name = ::std::option::Option::None;
            self.persona_name = ::std::option::Option::None;
            self.profile_url = ::std::option::Option::None;
            self.avatar_url = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Payment {
            static instance: Payment = Payment {
                transid: ::std::option::Option::None,
                steamid: ::std::option::Option::None,
                amount: ::std::option::Option::None,
                ecurrency: ::std::option::Option::None,
                time_created: ::std::option::Option::None,
                purchase_status: ::std::option::Option::None,
                machine_name: ::std::option::Option::None,
                persona_name: ::std::option::Option::None,
                profile_url: ::std::option::Option::None,
                avatar_url: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

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

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

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

    // optional fixed64 site_steamid = 1;

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

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

    pub fn has_site_steamid(&self) -> bool {
        self.site_steamid.is_some()
    }

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

    // optional fixed64 site_instanceid = 2;

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

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

    pub fn has_site_instanceid(&self) -> bool {
        self.site_instanceid.is_some()
    }

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

    // optional fixed32 client_local_ip = 3;

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

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

    pub fn has_client_local_ip(&self) -> bool {
        self.client_local_ip.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                9 => {
                    self.site_steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                17 => {
                    self.site_instanceid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                29 => {
                    self.client_local_ip = ::std::option::Option::Some(is.read_fixed32()?);
                },
                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.site_steamid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.site_instanceid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.client_local_ip {
            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.site_steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.site_instanceid {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.client_local_ip {
            os.write_fixed32(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() -> CSiteLicense_InitiateAssociation_Request {
        CSiteLicense_InitiateAssociation_Request::new()
    }

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

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

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

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

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

    // optional bytes connection_key = 1;

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

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

    pub fn has_connection_key(&self) -> bool {
        self.connection_key.is_some()
    }

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

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

impl ::steam_vent_proto_common::protobuf::Message for CSiteLicense_InitiateAssociation_Response {
    const NAME: &'static str = "CSiteLicense_InitiateAssociation_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.connection_key = ::std::option::Option::Some(is.read_bytes()?);
                },
                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.connection_key.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_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.connection_key.as_ref() {
            os.write_bytes(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() -> CSiteLicense_InitiateAssociation_Response {
        CSiteLicense_InitiateAssociation_Response::new()
    }

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

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

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

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

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

    // optional fixed64 instanceid = 1;

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                9 => {
                    self.instanceid = ::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.instanceid {
            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.instanceid {
            os.write_fixed64(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() -> CSiteLicense_LCSAuthenticate_Request {
        CSiteLicense_LCSAuthenticate_Request::new()
    }

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

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

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

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

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

    // optional uint64 site_id = 1;

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

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

    pub fn has_site_id(&self) -> bool {
        self.site_id.is_some()
    }

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

    // optional string site_name = 2;

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

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

    pub fn has_site_name(&self) -> bool {
        self.site_name.is_some()
    }

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

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

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

    // optional bool new_session = 3;

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

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

    pub fn has_new_session(&self) -> bool {
        self.new_session.is_some()
    }

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

    // optional bool no_site_licenses = 4;

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

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

    pub fn has_no_site_licenses(&self) -> bool {
        self.no_site_licenses.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CSiteLicense_LCSAuthenticate_Response {
    const NAME: &'static str = "CSiteLicense_LCSAuthenticate_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.site_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                18 => {
                    self.site_name = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.new_session = ::std::option::Option::Some(is.read_bool()?);
                },
                32 => {
                    self.no_site_licenses = ::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.site_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.site_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.new_session {
            my_size += 1 + 1;
        }
        if let Some(v) = self.no_site_licenses {
            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.site_id {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.site_name.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.new_session {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.no_site_licenses {
            os.write_bool(4, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.site_id = ::std::option::Option::None;
        self.site_name = ::std::option::Option::None;
        self.new_session = ::std::option::Option::None;
        self.no_site_licenses = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CSiteLicense_LCSAuthenticate_Response {
        static instance: CSiteLicense_LCSAuthenticate_Response = CSiteLicense_LCSAuthenticate_Response {
            site_id: ::std::option::Option::None,
            site_name: ::std::option::Option::None,
            new_session: ::std::option::Option::None,
            no_site_licenses: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional fixed64 steamid = 1;

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

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

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

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

    // optional fixed32 local_ip = 2;

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

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

    pub fn has_local_ip(&self) -> bool {
        self.local_ip.is_some()
    }

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

    // optional fixed64 instanceid = 3;

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

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

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

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

    // optional string machine_name = 4;

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

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

    pub fn has_machine_name(&self) -> bool {
        self.machine_name.is_some()
    }

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                9 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                21 => {
                    self.local_ip = ::std::option::Option::Some(is.read_fixed32()?);
                },
                25 => {
                    self.instanceid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                34 => {
                    self.machine_name = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.steamid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.local_ip {
            my_size += 1 + 4;
        }
        if let Some(v) = self.instanceid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.machine_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_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.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.local_ip {
            os.write_fixed32(2, v)?;
        }
        if let Some(v) = self.instanceid {
            os.write_fixed64(3, v)?;
        }
        if let Some(v) = self.machine_name.as_ref() {
            os.write_string(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() -> CSiteLicense_LCSAssociateUser_Request {
        CSiteLicense_LCSAssociateUser_Request::new()
    }

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

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for CSiteLicense_LCSAssociateUser_Response {
    const NAME: &'static str = "CSiteLicense_LCSAssociateUser_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 {
                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() -> CSiteLicense_LCSAssociateUser_Response {
        CSiteLicense_LCSAssociateUser_Response::new()
    }

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

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

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

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

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

    // optional fixed64 steamid = 1;

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

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

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

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

    // optional fixed64 instanceid = 2;

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

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

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

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

    // optional uint32 appid = 3;

    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 CSiteLicense_ClientSeatCheckout_Request {
    const NAME: &'static str = "CSiteLicense_ClientSeatCheckout_Request";

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                9 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                17 => {
                    self.instanceid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                24 => {
                    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.steamid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.instanceid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_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.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.instanceid {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(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() -> CSiteLicense_ClientSeatCheckout_Request {
        CSiteLicense_ClientSeatCheckout_Request::new()
    }

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

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for CSiteLicense_ClientSeatCheckout_Response {
    const NAME: &'static str = "CSiteLicense_ClientSeatCheckout_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 {
                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() -> CSiteLicense_ClientSeatCheckout_Response {
        CSiteLicense_ClientSeatCheckout_Response::new()
    }

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

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

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

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

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

    // optional fixed64 steamid = 1;

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

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

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

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

    // optional fixed64 instanceid = 2;

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

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

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

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

    // optional uint32 appid = 3;

    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 CSiteLicense_ClientGetAvailableSeats_Request {
    const NAME: &'static str = "CSiteLicense_ClientGetAvailableSeats_Request";

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                9 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                17 => {
                    self.instanceid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                24 => {
                    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.steamid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.instanceid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_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.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.instanceid {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(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() -> CSiteLicense_ClientGetAvailableSeats_Request {
        CSiteLicense_ClientGetAvailableSeats_Request::new()
    }

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

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

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

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

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

    // optional uint32 available_seats = 1;

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

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

    pub fn has_available_seats(&self) -> bool {
        self.available_seats.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CSiteLicense_ClientGetAvailableSeats_Response {
    const NAME: &'static str = "CSiteLicense_ClientGetAvailableSeats_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.available_seats = ::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.available_seats {
            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.available_seats {
            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() -> CSiteLicense_ClientGetAvailableSeats_Response {
        CSiteLicense_ClientGetAvailableSeats_Response::new()
    }

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

    fn default_instance() -> &'static CSiteLicense_ClientGetAvailableSeats_Response {
        static instance: CSiteLicense_ClientGetAvailableSeats_Response = CSiteLicense_ClientGetAvailableSeats_Response {
            available_seats: ::std::option::Option::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 CSiteManagerClient_IncomingClient_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 CSiteManagerClient_IncomingClient_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 CSiteLicense_ClientSeatCheckout_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
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CSiteManagerClient_TrackedPayments_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
    }
}
impl ::steam_vent_proto_common::RpcMessage for CSiteLicense_InitiateAssociation_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 CSiteLicense_InitiateAssociation_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 CSiteLicense_LCSAuthenticate_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 CSiteLicense_LCSAuthenticate_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 CSiteLicense_LCSAssociateUser_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 CSiteLicense_LCSAssociateUser_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 CSiteLicense_ClientSeatCheckout_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 CSiteLicense_ClientSeatCheckout_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 CSiteLicense_ClientGetAvailableSeats_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 CSiteLicense_ClientGetAvailableSeats_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
///
struct SiteManagerClient {}
impl ::steam_vent_proto_common::RpcService for SiteManagerClient {
    const SERVICE_NAME: &'static str = "SiteManagerClient";
}
///
struct SiteLicense {}
impl ::steam_vent_proto_common::RpcService for SiteLicense {
    const SERVICE_NAME: &'static str = "SiteLicense";
}
impl ::steam_vent_proto_common::RpcMethod
for CSiteLicense_ClientGetAvailableSeats_Request {
    const METHOD_NAME: &'static str = "SiteLicense.ClientGetAvailableSeats#1";
    type Response = CSiteLicense_ClientGetAvailableSeats_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CSiteLicense_ClientSeatCheckout_Notification {
    const METHOD_NAME: &'static str = "SiteManagerClient.ClientSeatCheckoutNotification#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CSiteLicense_ClientSeatCheckout_Request {
    const METHOD_NAME: &'static str = "SiteLicense.ClientSeatCheckout#1";
    type Response = CSiteLicense_ClientSeatCheckout_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CSiteLicense_InitiateAssociation_Request {
    const METHOD_NAME: &'static str = "SiteLicense.InitiateAssociation#1";
    type Response = CSiteLicense_InitiateAssociation_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CSiteLicense_LCSAssociateUser_Request {
    const METHOD_NAME: &'static str = "SiteLicense.LCSAssociateUser#1";
    type Response = CSiteLicense_LCSAssociateUser_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CSiteLicense_LCSAuthenticate_Request {
    const METHOD_NAME: &'static str = "SiteLicense.LCSAuthenticate#1";
    type Response = CSiteLicense_LCSAuthenticate_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CSiteManagerClient_IncomingClient_Request {
    const METHOD_NAME: &'static str = "SiteManagerClient.IncomingClient#1";
    type Response = CSiteManagerClient_IncomingClient_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CSiteManagerClient_TrackedPayments_Notification {
    const METHOD_NAME: &'static str = "SiteManagerClient.TrackedPaymentsNotification#1";
    type Response = ();
}
