steam-vent-proto 0.1.0

// This file is generated by rust-protobuf 2.24.1. Do not edit
// @generated

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

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

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `steammessages_site_license.steamclient.proto`

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

#[derive(PartialEq,Clone,Default)]
pub struct CSiteManagerClient_IncomingClient_Request {
    // message fields
    site_instanceid: ::std::option::Option<u64>,
    client_steamid: ::std::option::Option<u64>,
    client_local_ip: ::std::option::Option<u32>,
    connection_key: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CSiteManagerClient_IncomingClient_Request {
    fn default() -> &'a CSiteManagerClient_IncomingClient_Request {
        <CSiteManagerClient_IncomingClient_Request as ::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 get_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 get_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 get_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 get_connection_key(&self) -> &[u8] {
        match self.connection_key.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_connection_key(&mut self) {
        self.connection_key.clear();
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.site_instanceid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.client_steamid = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.client_local_ip = ::std::option::Option::Some(tmp);
                },
                4 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.connection_key)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.site_instanceid {
            my_size += 9;
        }
        if let Some(v) = self.client_steamid {
            my_size += 9;
        }
        if let Some(v) = self.client_local_ip {
            my_size += 5;
        }
        if let Some(ref v) = self.connection_key.as_ref() {
            my_size += ::protobuf::rt::bytes_size(4, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(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(ref v) = self.connection_key.as_ref() {
            os.write_bytes(4, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "site_instanceid",
                |m: &CSiteManagerClient_IncomingClient_Request| { &m.site_instanceid },
                |m: &mut CSiteManagerClient_IncomingClient_Request| { &mut m.site_instanceid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "client_steamid",
                |m: &CSiteManagerClient_IncomingClient_Request| { &m.client_steamid },
                |m: &mut CSiteManagerClient_IncomingClient_Request| { &mut m.client_steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "client_local_ip",
                |m: &CSiteManagerClient_IncomingClient_Request| { &m.client_local_ip },
                |m: &mut CSiteManagerClient_IncomingClient_Request| { &mut m.client_local_ip },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "connection_key",
                |m: &CSiteManagerClient_IncomingClient_Request| { &m.connection_key },
                |m: &mut CSiteManagerClient_IncomingClient_Request| { &mut m.connection_key },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CSiteManagerClient_IncomingClient_Request>(
                "CSiteManagerClient_IncomingClient_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CSiteManagerClient_IncomingClient_Request {
    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.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional uint32 appid = 1;


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

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

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

    // optional uint32 eresult = 2;


    pub fn get_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 ::protobuf::Message for CSiteLicense_ClientSeatCheckout_Notification {
    fn is_initialized(&self) -> bool {
        true
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CSiteManagerClient_TrackedPayments_Notification {
    // message fields
    site_id: ::std::option::Option<u64>,
    pub payments: ::protobuf::RepeatedField<CSiteManagerClient_TrackedPayments_Notification_Payment>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CSiteManagerClient_TrackedPayments_Notification {
    fn default() -> &'a CSiteManagerClient_TrackedPayments_Notification {
        <CSiteManagerClient_TrackedPayments_Notification as ::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 get_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);
    }

    // repeated .CSiteManagerClient_TrackedPayments_Notification.Payment payments = 2;


    pub fn get_payments(&self) -> &[CSiteManagerClient_TrackedPayments_Notification_Payment] {
        &self.payments
    }
    pub fn clear_payments(&mut self) {
        self.payments.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_payments(&mut self) -> &mut ::protobuf::RepeatedField<CSiteManagerClient_TrackedPayments_Notification_Payment> {
        &mut self.payments
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CSiteManagerClient_TrackedPayments_Notification_Payment {
    // message fields
    transid: ::std::option::Option<u64>,
    steamid: ::std::option::Option<u64>,
    amount: ::std::option::Option<i64>,
    ecurrency: ::std::option::Option<u32>,
    time_created: ::std::option::Option<i32>,
    purchase_status: ::std::option::Option<i32>,
    machine_name: ::protobuf::SingularField<::std::string::String>,
    persona_name: ::protobuf::SingularField<::std::string::String>,
    profile_url: ::protobuf::SingularField<::std::string::String>,
    avatar_url: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint64 transid = 1;


    pub fn get_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 get_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 get_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 get_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 get_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 get_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 get_machine_name(&self) -> &str {
        match self.machine_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_machine_name(&mut self) {
        self.machine_name.clear();
    }

    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 = ::protobuf::SingularField::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.set_default();
        }
        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 get_persona_name(&self) -> &str {
        match self.persona_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_persona_name(&mut self) {
        self.persona_name.clear();
    }

    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 = ::protobuf::SingularField::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.set_default();
        }
        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 get_profile_url(&self) -> &str {
        match self.profile_url.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_profile_url(&mut self) {
        self.profile_url.clear();
    }

    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 = ::protobuf::SingularField::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.set_default();
        }
        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 get_avatar_url(&self) -> &str {
        match self.avatar_url.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_avatar_url(&mut self) {
        self.avatar_url.clear();
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.transid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.steamid = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.amount = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.ecurrency = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.time_created = ::std::option::Option::Some(tmp);
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.purchase_status = ::std::option::Option::Some(tmp);
                },
                7 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.machine_name)?;
                },
                8 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.persona_name)?;
                },
                9 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.profile_url)?;
                },
                10 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.avatar_url)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.transid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.steamid {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.amount {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.ecurrency {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.time_created {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.purchase_status {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.machine_name.as_ref() {
            my_size += ::protobuf::rt::string_size(7, &v);
        }
        if let Some(ref v) = self.persona_name.as_ref() {
            my_size += ::protobuf::rt::string_size(8, &v);
        }
        if let Some(ref v) = self.profile_url.as_ref() {
            my_size += ::protobuf::rt::string_size(9, &v);
        }
        if let Some(ref v) = self.avatar_url.as_ref() {
            my_size += ::protobuf::rt::string_size(10, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.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(ref v) = self.machine_name.as_ref() {
            os.write_string(7, &v)?;
        }
        if let Some(ref v) = self.persona_name.as_ref() {
            os.write_string(8, &v)?;
        }
        if let Some(ref v) = self.profile_url.as_ref() {
            os.write_string(9, &v)?;
        }
        if let Some(ref v) = self.avatar_url.as_ref() {
            os.write_string(10, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "transid",
                |m: &CSiteManagerClient_TrackedPayments_Notification_Payment| { &m.transid },
                |m: &mut CSiteManagerClient_TrackedPayments_Notification_Payment| { &mut m.transid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "steamid",
                |m: &CSiteManagerClient_TrackedPayments_Notification_Payment| { &m.steamid },
                |m: &mut CSiteManagerClient_TrackedPayments_Notification_Payment| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "amount",
                |m: &CSiteManagerClient_TrackedPayments_Notification_Payment| { &m.amount },
                |m: &mut CSiteManagerClient_TrackedPayments_Notification_Payment| { &mut m.amount },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "ecurrency",
                |m: &CSiteManagerClient_TrackedPayments_Notification_Payment| { &m.ecurrency },
                |m: &mut CSiteManagerClient_TrackedPayments_Notification_Payment| { &mut m.ecurrency },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "time_created",
                |m: &CSiteManagerClient_TrackedPayments_Notification_Payment| { &m.time_created },
                |m: &mut CSiteManagerClient_TrackedPayments_Notification_Payment| { &mut m.time_created },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "purchase_status",
                |m: &CSiteManagerClient_TrackedPayments_Notification_Payment| { &m.purchase_status },
                |m: &mut CSiteManagerClient_TrackedPayments_Notification_Payment| { &mut m.purchase_status },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "machine_name",
                |m: &CSiteManagerClient_TrackedPayments_Notification_Payment| { &m.machine_name },
                |m: &mut CSiteManagerClient_TrackedPayments_Notification_Payment| { &mut m.machine_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "persona_name",
                |m: &CSiteManagerClient_TrackedPayments_Notification_Payment| { &m.persona_name },
                |m: &mut CSiteManagerClient_TrackedPayments_Notification_Payment| { &mut m.persona_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "profile_url",
                |m: &CSiteManagerClient_TrackedPayments_Notification_Payment| { &m.profile_url },
                |m: &mut CSiteManagerClient_TrackedPayments_Notification_Payment| { &mut m.profile_url },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "avatar_url",
                |m: &CSiteManagerClient_TrackedPayments_Notification_Payment| { &m.avatar_url },
                |m: &mut CSiteManagerClient_TrackedPayments_Notification_Payment| { &mut m.avatar_url },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CSiteManagerClient_TrackedPayments_Notification_Payment>(
                "CSiteManagerClient_TrackedPayments_Notification.Payment",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CSiteManagerClient_TrackedPayments_Notification_Payment {
    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.clear();
        self.persona_name.clear();
        self.profile_url.clear();
        self.avatar_url.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CSiteLicense_InitiateAssociation_Request {
    // message fields
    site_steamid: ::std::option::Option<u64>,
    site_instanceid: ::std::option::Option<u64>,
    client_local_ip: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CSiteLicense_InitiateAssociation_Request {
    fn default() -> &'a CSiteLicense_InitiateAssociation_Request {
        <CSiteLicense_InitiateAssociation_Request as ::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 get_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 get_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 get_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 ::protobuf::Message for CSiteLicense_InitiateAssociation_Request {
    fn is_initialized(&self) -> bool {
        true
    }

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.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.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "site_steamid",
                |m: &CSiteLicense_InitiateAssociation_Request| { &m.site_steamid },
                |m: &mut CSiteLicense_InitiateAssociation_Request| { &mut m.site_steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "site_instanceid",
                |m: &CSiteLicense_InitiateAssociation_Request| { &m.site_instanceid },
                |m: &mut CSiteLicense_InitiateAssociation_Request| { &mut m.site_instanceid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "client_local_ip",
                |m: &CSiteLicense_InitiateAssociation_Request| { &m.client_local_ip },
                |m: &mut CSiteLicense_InitiateAssociation_Request| { &mut m.client_local_ip },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CSiteLicense_InitiateAssociation_Request>(
                "CSiteLicense_InitiateAssociation_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CSiteLicense_InitiateAssociation_Request {
    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.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CSiteLicense_InitiateAssociation_Response {
    // message fields
    connection_key: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CSiteLicense_InitiateAssociation_Response {
    fn default() -> &'a CSiteLicense_InitiateAssociation_Response {
        <CSiteLicense_InitiateAssociation_Response as ::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 get_connection_key(&self) -> &[u8] {
        match self.connection_key.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_connection_key(&mut self) {
        self.connection_key.clear();
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional fixed64 instanceid = 1;


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CSiteLicense_LCSAuthenticate_Response {
    // message fields
    site_id: ::std::option::Option<u64>,
    site_name: ::protobuf::SingularField<::std::string::String>,
    new_session: ::std::option::Option<bool>,
    no_site_licenses: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CSiteLicense_LCSAuthenticate_Response {
    fn default() -> &'a CSiteLicense_LCSAuthenticate_Response {
        <CSiteLicense_LCSAuthenticate_Response as ::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 get_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 get_site_name(&self) -> &str {
        match self.site_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_site_name(&mut self) {
        self.site_name.clear();
    }

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.site_id {
            os.write_uint64(1, v)?;
        }
        if let Some(ref 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.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

impl ::protobuf::Clear for CSiteLicense_LCSAuthenticate_Response {
    fn clear(&mut self) {
        self.site_id = ::std::option::Option::None;
        self.site_name.clear();
        self.new_session = ::std::option::Option::None;
        self.no_site_licenses = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CSiteLicense_LCSAssociateUser_Request {
    // message fields
    steamid: ::std::option::Option<u64>,
    local_ip: ::std::option::Option<u32>,
    instanceid: ::std::option::Option<u64>,
    machine_name: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 steamid = 1;


    pub fn get_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 get_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 get_instanceid(&self) -> u64 {
        self.instanceid.unwrap_or(0)
    }
    pub fn clear_instanceid(&mut self) {
        self.instanceid = ::std::option::Option::None;
    }

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

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

    // optional string machine_name = 4;


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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.local_ip = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.instanceid = ::std::option::Option::Some(tmp);
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.machine_name)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

impl ::protobuf::Clear for CSiteLicense_LCSAssociateUser_Request {
    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.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional fixed64 steamid = 1;


    pub fn get_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 get_instanceid(&self) -> u64 {
        self.instanceid.unwrap_or(0)
    }
    pub fn clear_instanceid(&mut self) {
        self.instanceid = ::std::option::Option::None;
    }

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

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

    // optional uint32 appid = 3;


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

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.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.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional fixed64 steamid = 1;


    pub fn get_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 get_instanceid(&self) -> u64 {
        self.instanceid.unwrap_or(0)
    }
    pub fn clear_instanceid(&mut self) {
        self.instanceid = ::std::option::Option::None;
    }

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

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

    // optional uint32 appid = 3;


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

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.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.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a> ::std::default::Default for &'a CSiteLicense_ClientGetAvailableSeats_Response {
    fn default() -> &'a CSiteLicense_ClientGetAvailableSeats_Response {
        <CSiteLicense_ClientGetAvailableSeats_Response as ::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 get_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 ::protobuf::Message for CSiteLicense_ClientGetAvailableSeats_Response {
    fn is_initialized(&self) -> bool {
        true
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n,steammessages_site_license.steamclient.proto\x1a,steammessages_unifie\
    d_base.steamclient.proto\"\xca\x01\n)CSiteManagerClient_IncomingClient_R\
    equest\x12'\n\x0fsite_instanceid\x18\x01\x20\x01(\x06R\x0esiteInstanceid\
    \x12%\n\x0eclient_steamid\x18\x02\x20\x01(\x06R\rclientSteamid\x12&\n\
    \x0fclient_local_ip\x18\x03\x20\x01(\x07R\rclientLocalIp\x12%\n\x0econne\
    ction_key\x18\x04\x20\x01(\x0cR\rconnectionKey\",\n*CSiteManagerClient_I\
    ncomingClient_Response\"^\n,CSiteLicense_ClientSeatCheckout_Notification\
    \x12\x14\n\x05appid\x18\x01\x20\x01(\rR\x05appid\x12\x18\n\x07eresult\
    \x18\x02\x20\x01(\rR\x07eresult\"\xe8\x03\n/CSiteManagerClient_TrackedPa\
    yments_Notification\x12\x17\n\x07site_id\x18\x01\x20\x01(\x06R\x06siteId\
    \x12T\n\x08payments\x18\x02\x20\x03(\x0b28.CSiteManagerClient_TrackedPay\
    ments_Notification.PaymentR\x08payments\x1a\xc5\x02\n\x07Payment\x12\x18\
    \n\x07transid\x18\x01\x20\x01(\x04R\x07transid\x12\x18\n\x07steamid\x18\
    \x02\x20\x01(\x04R\x07steamid\x12\x16\n\x06amount\x18\x03\x20\x01(\x03R\
    \x06amount\x12\x1c\n\tecurrency\x18\x04\x20\x01(\rR\tecurrency\x12!\n\
    \x0ctime_created\x18\x05\x20\x01(\x05R\x0btimeCreated\x12'\n\x0fpurchase\
    _status\x18\x06\x20\x01(\x05R\x0epurchaseStatus\x12!\n\x0cmachine_name\
    \x18\x07\x20\x01(\tR\x0bmachineName\x12!\n\x0cpersona_name\x18\x08\x20\
    \x01(\tR\x0bpersonaName\x12\x1f\n\x0bprofile_url\x18\t\x20\x01(\tR\nprof\
    ileUrl\x12\x1d\n\navatar_url\x18\n\x20\x01(\tR\tavatarUrl\"\x9e\x01\n(CS\
    iteLicense_InitiateAssociation_Request\x12!\n\x0csite_steamid\x18\x01\
    \x20\x01(\x06R\x0bsiteSteamid\x12'\n\x0fsite_instanceid\x18\x02\x20\x01(\
    \x06R\x0esiteInstanceid\x12&\n\x0fclient_local_ip\x18\x03\x20\x01(\x07R\
    \rclientLocalIp\"R\n)CSiteLicense_InitiateAssociation_Response\x12%\n\
    \x0econnection_key\x18\x01\x20\x01(\x0cR\rconnectionKey\"F\n$CSiteLicens\
    e_LCSAuthenticate_Request\x12\x1e\n\ninstanceid\x18\x01\x20\x01(\x06R\ni\
    nstanceid\"\xa8\x01\n%CSiteLicense_LCSAuthenticate_Response\x12\x17\n\
    \x07site_id\x18\x01\x20\x01(\x04R\x06siteId\x12\x1b\n\tsite_name\x18\x02\
    \x20\x01(\tR\x08siteName\x12\x1f\n\x0bnew_session\x18\x03\x20\x01(\x08R\
    \nnewSession\x12(\n\x10no_site_licenses\x18\x04\x20\x01(\x08R\x0enoSiteL\
    icenses\"\x9f\x01\n%CSiteLicense_LCSAssociateUser_Request\x12\x18\n\x07s\
    teamid\x18\x01\x20\x01(\x06R\x07steamid\x12\x19\n\x08local_ip\x18\x02\
    \x20\x01(\x07R\x07localIp\x12\x1e\n\ninstanceid\x18\x03\x20\x01(\x06R\ni\
    nstanceid\x12!\n\x0cmachine_name\x18\x04\x20\x01(\tR\x0bmachineName\"(\n\
    &CSiteLicense_LCSAssociateUser_Response\"y\n'CSiteLicense_ClientSeatChec\
    kout_Request\x12\x18\n\x07steamid\x18\x01\x20\x01(\x06R\x07steamid\x12\
    \x1e\n\ninstanceid\x18\x02\x20\x01(\x06R\ninstanceid\x12\x14\n\x05appid\
    \x18\x03\x20\x01(\rR\x05appid\"*\n(CSiteLicense_ClientSeatCheckout_Respo\
    nse\"~\n,CSiteLicense_ClientGetAvailableSeats_Request\x12\x18\n\x07steam\
    id\x18\x01\x20\x01(\x06R\x07steamid\x12\x1e\n\ninstanceid\x18\x02\x20\
    \x01(\x06R\ninstanceid\x12\x14\n\x05appid\x18\x03\x20\x01(\rR\x05appid\"\
    X\n-CSiteLicense_ClientGetAvailableSeats_Response\x12'\n\x0favailable_se\
    ats\x18\x01\x20\x01(\rR\x0eavailableSeats2\xa3\x04\n\x11SiteManagerClien\
    t\x12\xaf\x01\n\x0eIncomingClient\x12*.CSiteManagerClient_IncomingClient\
    _Request\x1a+.CSiteManagerClient_IncomingClient_Response\"D\x82\xb5\x18@\
    Rack\x20informing\x20site\x20manager\x20of\x20new\x20inbound\x20client\
    \x20PSK\x20connection\x12\x93\x01\n\x1eClientSeatCheckoutNotification\
    \x12-.CSiteLicense_ClientSeatCheckout_Notification\x1a\x0b.NoResponse\"5\
    \x82\xb5\x181Notify\x20client\x20directly\x20about\x20seat\x20checkout\
    \x20result\x12\x9a\x01\n\x1bTrackedPaymentsNotification\x120.CSiteManage\
    rClient_TrackedPayments_Notification\x1a\x0b.NoResponse\"<\x82\xb5\x188R\
    ack\x20informing\x20site\x20manager\x20of\x20existing\x20tracked\x20paym\
    ents\x1a)\x82\xb5\x18!Local\x20site\x20manager\x20client\x20service\xc0\
    \xb5\x18\x022\xd5\x06\n\x0bSiteLicense\x12\xa4\x01\n\x13InitiateAssociat\
    ion\x12).CSiteLicense_InitiateAssociation_Request\x1a*.CSiteLicense_Init\
    iateAssociation_Response\"6\x82\xb5\x182Client\x20is\x20requesting\x20co\
    nnetion\x20info\x20for\x20local\x20site\x12\x86\x01\n\x0fLCSAuthenticate\
    \x12%.CSiteLicense_LCSAuthenticate_Request\x1a&.CSiteLicense_LCSAuthenti\
    cate_Response\"$\x82\xb5\x18\x20Local\x20cafe\x20server\x20authenticatio\
    n\x12\x9d\x01\n\x10LCSAssociateUser\x12&.CSiteLicense_LCSAssociateUser_R\
    equest\x1a'.CSiteLicense_LCSAssociateUser_Response\"8\x82\xb5\x184Local\
    \x20cafe\x20server\x20wants\x20to\x20grant\x20user\x20access\x20to\x20si\
    te\x12\x9e\x01\n\x12ClientSeatCheckout\x12(.CSiteLicense_ClientSeatCheck\
    out_Request\x1a).CSiteLicense_ClientSeatCheckout_Response\"3\x82\xb5\x18\
    /Client\x20is\x20requesting\x20use\x20of\x20a\x20site\x20license\x20seat\
    \x12\xba\x01\n\x17ClientGetAvailableSeats\x12-.CSiteLicense_ClientGetAva\
    ilableSeats_Request\x1a..CSiteLicense_ClientGetAvailableSeats_Response\"\
    @\x82\xb5\x18<Client\x20is\x20requesting\x20the\x20number\x20of\x20curre\
    ntly\x20available\x20seats\x1a\x18\x82\xb5\x18\x14Site\x20License\x20ser\
    viceB\x03\x80\x01\x01J\xf0\x1e\n\x06\x12\x04\0\0~\x01\n\t\n\x02\x03\0\
    \x12\x03\0\06\n\x08\n\x01\x08\x12\x03\x02\0\"\n\t\n\x02\x08\x10\x12\x03\
    \x02\0\"\n\n\n\x02\x04\0\x12\x04\x04\0\t\x01\n\n\n\x03\x04\0\x01\x12\x03\
    \x04\x081\n\x0b\n\x04\x04\0\x02\0\x12\x03\x05\x08-\n\x0c\n\x05\x04\0\x02\
    \0\x04\x12\x03\x05\x08\x10\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x05\x11\
    \x18\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x05\x19(\n\x0c\n\x05\x04\0\x02\
    \0\x03\x12\x03\x05+,\n\x0b\n\x04\x04\0\x02\x01\x12\x03\x06\x08,\n\x0c\n\
    \x05\x04\0\x02\x01\x04\x12\x03\x06\x08\x10\n\x0c\n\x05\x04\0\x02\x01\x05\
    \x12\x03\x06\x11\x18\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\x06\x19'\n\
    \x0c\n\x05\x04\0\x02\x01\x03\x12\x03\x06*+\n\x0b\n\x04\x04\0\x02\x02\x12\
    \x03\x07\x08-\n\x0c\n\x05\x04\0\x02\x02\x04\x12\x03\x07\x08\x10\n\x0c\n\
    \x05\x04\0\x02\x02\x05\x12\x03\x07\x11\x18\n\x0c\n\x05\x04\0\x02\x02\x01\
    \x12\x03\x07\x19(\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03\x07+,\n\x0b\n\
    \x04\x04\0\x02\x03\x12\x03\x08\x08*\n\x0c\n\x05\x04\0\x02\x03\x04\x12\
    \x03\x08\x08\x10\n\x0c\n\x05\x04\0\x02\x03\x05\x12\x03\x08\x11\x16\n\x0c\
    \n\x05\x04\0\x02\x03\x01\x12\x03\x08\x17%\n\x0c\n\x05\x04\0\x02\x03\x03\
    \x12\x03\x08()\n\n\n\x02\x04\x01\x12\x04\x0b\0\x0c\x01\n\n\n\x03\x04\x01\
    \x01\x12\x03\x0b\x082\n\n\n\x02\x04\x02\x12\x04\x0e\0\x11\x01\n\n\n\x03\
    \x04\x02\x01\x12\x03\x0e\x084\n\x0b\n\x04\x04\x02\x02\0\x12\x03\x0f\x08\
    \"\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03\x0f\x08\x10\n\x0c\n\x05\x04\x02\
    \x02\0\x05\x12\x03\x0f\x11\x17\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03\x0f\
    \x18\x1d\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03\x0f\x20!\n\x0b\n\x04\x04\
    \x02\x02\x01\x12\x03\x10\x08$\n\x0c\n\x05\x04\x02\x02\x01\x04\x12\x03\
    \x10\x08\x10\n\x0c\n\x05\x04\x02\x02\x01\x05\x12\x03\x10\x11\x17\n\x0c\n\
    \x05\x04\x02\x02\x01\x01\x12\x03\x10\x18\x1f\n\x0c\n\x05\x04\x02\x02\x01\
    \x03\x12\x03\x10\"#\n\n\n\x02\x04\x03\x12\x04\x13\0#\x01\n\n\n\x03\x04\
    \x03\x01\x12\x03\x13\x087\n\x0c\n\x04\x04\x03\x03\0\x12\x04\x14\x08\x1f\
    \t\n\x0c\n\x05\x04\x03\x03\0\x01\x12\x03\x14\x10\x17\n\r\n\x06\x04\x03\
    \x03\0\x02\0\x12\x03\x15\x10,\n\x0e\n\x07\x04\x03\x03\0\x02\0\x04\x12\
    \x03\x15\x10\x18\n\x0e\n\x07\x04\x03\x03\0\x02\0\x05\x12\x03\x15\x19\x1f\
    \n\x0e\n\x07\x04\x03\x03\0\x02\0\x01\x12\x03\x15\x20'\n\x0e\n\x07\x04\
    \x03\x03\0\x02\0\x03\x12\x03\x15*+\n\r\n\x06\x04\x03\x03\0\x02\x01\x12\
    \x03\x16\x10,\n\x0e\n\x07\x04\x03\x03\0\x02\x01\x04\x12\x03\x16\x10\x18\
    \n\x0e\n\x07\x04\x03\x03\0\x02\x01\x05\x12\x03\x16\x19\x1f\n\x0e\n\x07\
    \x04\x03\x03\0\x02\x01\x01\x12\x03\x16\x20'\n\x0e\n\x07\x04\x03\x03\0\
    \x02\x01\x03\x12\x03\x16*+\n\r\n\x06\x04\x03\x03\0\x02\x02\x12\x03\x17\
    \x10*\n\x0e\n\x07\x04\x03\x03\0\x02\x02\x04\x12\x03\x17\x10\x18\n\x0e\n\
    \x07\x04\x03\x03\0\x02\x02\x05\x12\x03\x17\x19\x1e\n\x0e\n\x07\x04\x03\
    \x03\0\x02\x02\x01\x12\x03\x17\x1f%\n\x0e\n\x07\x04\x03\x03\0\x02\x02\
    \x03\x12\x03\x17()\n\r\n\x06\x04\x03\x03\0\x02\x03\x12\x03\x18\x10.\n\
    \x0e\n\x07\x04\x03\x03\0\x02\x03\x04\x12\x03\x18\x10\x18\n\x0e\n\x07\x04\
    \x03\x03\0\x02\x03\x05\x12\x03\x18\x19\x1f\n\x0e\n\x07\x04\x03\x03\0\x02\
    \x03\x01\x12\x03\x18\x20)\n\x0e\n\x07\x04\x03\x03\0\x02\x03\x03\x12\x03\
    \x18,-\n\r\n\x06\x04\x03\x03\0\x02\x04\x12\x03\x19\x100\n\x0e\n\x07\x04\
    \x03\x03\0\x02\x04\x04\x12\x03\x19\x10\x18\n\x0e\n\x07\x04\x03\x03\0\x02\
    \x04\x05\x12\x03\x19\x19\x1e\n\x0e\n\x07\x04\x03\x03\0\x02\x04\x01\x12\
    \x03\x19\x1f+\n\x0e\n\x07\x04\x03\x03\0\x02\x04\x03\x12\x03\x19./\n\r\n\
    \x06\x04\x03\x03\0\x02\x05\x12\x03\x1a\x103\n\x0e\n\x07\x04\x03\x03\0\
    \x02\x05\x04\x12\x03\x1a\x10\x18\n\x0e\n\x07\x04\x03\x03\0\x02\x05\x05\
    \x12\x03\x1a\x19\x1e\n\x0e\n\x07\x04\x03\x03\0\x02\x05\x01\x12\x03\x1a\
    \x1f.\n\x0e\n\x07\x04\x03\x03\0\x02\x05\x03\x12\x03\x1a12\n\r\n\x06\x04\
    \x03\x03\0\x02\x06\x12\x03\x1b\x101\n\x0e\n\x07\x04\x03\x03\0\x02\x06\
    \x04\x12\x03\x1b\x10\x18\n\x0e\n\x07\x04\x03\x03\0\x02\x06\x05\x12\x03\
    \x1b\x19\x1f\n\x0e\n\x07\x04\x03\x03\0\x02\x06\x01\x12\x03\x1b\x20,\n\
    \x0e\n\x07\x04\x03\x03\0\x02\x06\x03\x12\x03\x1b/0\n\r\n\x06\x04\x03\x03\
    \0\x02\x07\x12\x03\x1c\x101\n\x0e\n\x07\x04\x03\x03\0\x02\x07\x04\x12\
    \x03\x1c\x10\x18\n\x0e\n\x07\x04\x03\x03\0\x02\x07\x05\x12\x03\x1c\x19\
    \x1f\n\x0e\n\x07\x04\x03\x03\0\x02\x07\x01\x12\x03\x1c\x20,\n\x0e\n\x07\
    \x04\x03\x03\0\x02\x07\x03\x12\x03\x1c/0\n\r\n\x06\x04\x03\x03\0\x02\x08\
    \x12\x03\x1d\x100\n\x0e\n\x07\x04\x03\x03\0\x02\x08\x04\x12\x03\x1d\x10\
    \x18\n\x0e\n\x07\x04\x03\x03\0\x02\x08\x05\x12\x03\x1d\x19\x1f\n\x0e\n\
    \x07\x04\x03\x03\0\x02\x08\x01\x12\x03\x1d\x20+\n\x0e\n\x07\x04\x03\x03\
    \0\x02\x08\x03\x12\x03\x1d./\n\r\n\x06\x04\x03\x03\0\x02\t\x12\x03\x1e\
    \x100\n\x0e\n\x07\x04\x03\x03\0\x02\t\x04\x12\x03\x1e\x10\x18\n\x0e\n\
    \x07\x04\x03\x03\0\x02\t\x05\x12\x03\x1e\x19\x1f\n\x0e\n\x07\x04\x03\x03\
    \0\x02\t\x01\x12\x03\x1e\x20*\n\x0e\n\x07\x04\x03\x03\0\x02\t\x03\x12\
    \x03\x1e-/\n\x0b\n\x04\x04\x03\x02\0\x12\x03!\x08%\n\x0c\n\x05\x04\x03\
    \x02\0\x04\x12\x03!\x08\x10\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x03!\x11\
    \x18\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03!\x19\x20\n\x0c\n\x05\x04\x03\
    \x02\0\x03\x12\x03!#$\n\x0b\n\x04\x04\x03\x02\x01\x12\x03\"\x08W\n\x0c\n\
    \x05\x04\x03\x02\x01\x04\x12\x03\"\x08\x10\n\x0c\n\x05\x04\x03\x02\x01\
    \x06\x12\x03\"\x11I\n\x0c\n\x05\x04\x03\x02\x01\x01\x12\x03\"JR\n\x0c\n\
    \x05\x04\x03\x02\x01\x03\x12\x03\"UV\n\n\n\x02\x04\x04\x12\x04%\0)\x01\n\
    \n\n\x03\x04\x04\x01\x12\x03%\x080\n\x0b\n\x04\x04\x04\x02\0\x12\x03&\
    \x08*\n\x0c\n\x05\x04\x04\x02\0\x04\x12\x03&\x08\x10\n\x0c\n\x05\x04\x04\
    \x02\0\x05\x12\x03&\x11\x18\n\x0c\n\x05\x04\x04\x02\0\x01\x12\x03&\x19%\
    \n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03&()\n\x0b\n\x04\x04\x04\x02\x01\
    \x12\x03'\x08-\n\x0c\n\x05\x04\x04\x02\x01\x04\x12\x03'\x08\x10\n\x0c\n\
    \x05\x04\x04\x02\x01\x05\x12\x03'\x11\x18\n\x0c\n\x05\x04\x04\x02\x01\
    \x01\x12\x03'\x19(\n\x0c\n\x05\x04\x04\x02\x01\x03\x12\x03'+,\n\x0b\n\
    \x04\x04\x04\x02\x02\x12\x03(\x08-\n\x0c\n\x05\x04\x04\x02\x02\x04\x12\
    \x03(\x08\x10\n\x0c\n\x05\x04\x04\x02\x02\x05\x12\x03(\x11\x18\n\x0c\n\
    \x05\x04\x04\x02\x02\x01\x12\x03(\x19(\n\x0c\n\x05\x04\x04\x02\x02\x03\
    \x12\x03(+,\n\n\n\x02\x04\x05\x12\x04+\0-\x01\n\n\n\x03\x04\x05\x01\x12\
    \x03+\x081\n\x0b\n\x04\x04\x05\x02\0\x12\x03,\x08*\n\x0c\n\x05\x04\x05\
    \x02\0\x04\x12\x03,\x08\x10\n\x0c\n\x05\x04\x05\x02\0\x05\x12\x03,\x11\
    \x16\n\x0c\n\x05\x04\x05\x02\0\x01\x12\x03,\x17%\n\x0c\n\x05\x04\x05\x02\
    \0\x03\x12\x03,()\n\n\n\x02\x04\x06\x12\x04/\01\x01\n\n\n\x03\x04\x06\
    \x01\x12\x03/\x08,\n\x0b\n\x04\x04\x06\x02\0\x12\x030\x08(\n\x0c\n\x05\
    \x04\x06\x02\0\x04\x12\x030\x08\x10\n\x0c\n\x05\x04\x06\x02\0\x05\x12\
    \x030\x11\x18\n\x0c\n\x05\x04\x06\x02\0\x01\x12\x030\x19#\n\x0c\n\x05\
    \x04\x06\x02\0\x03\x12\x030&'\n\n\n\x02\x04\x07\x12\x043\08\x01\n\n\n\
    \x03\x04\x07\x01\x12\x033\x08-\n\x0b\n\x04\x04\x07\x02\0\x12\x034\x08$\n\
    \x0c\n\x05\x04\x07\x02\0\x04\x12\x034\x08\x10\n\x0c\n\x05\x04\x07\x02\0\
    \x05\x12\x034\x11\x17\n\x0c\n\x05\x04\x07\x02\0\x01\x12\x034\x18\x1f\n\
    \x0c\n\x05\x04\x07\x02\0\x03\x12\x034\"#\n\x0b\n\x04\x04\x07\x02\x01\x12\
    \x035\x08&\n\x0c\n\x05\x04\x07\x02\x01\x04\x12\x035\x08\x10\n\x0c\n\x05\
    \x04\x07\x02\x01\x05\x12\x035\x11\x17\n\x0c\n\x05\x04\x07\x02\x01\x01\
    \x12\x035\x18!\n\x0c\n\x05\x04\x07\x02\x01\x03\x12\x035$%\n\x0b\n\x04\
    \x04\x07\x02\x02\x12\x036\x08&\n\x0c\n\x05\x04\x07\x02\x02\x04\x12\x036\
    \x08\x10\n\x0c\n\x05\x04\x07\x02\x02\x05\x12\x036\x11\x15\n\x0c\n\x05\
    \x04\x07\x02\x02\x01\x12\x036\x16!\n\x0c\n\x05\x04\x07\x02\x02\x03\x12\
    \x036$%\n\x0b\n\x04\x04\x07\x02\x03\x12\x037\x08+\n\x0c\n\x05\x04\x07\
    \x02\x03\x04\x12\x037\x08\x10\n\x0c\n\x05\x04\x07\x02\x03\x05\x12\x037\
    \x11\x15\n\x0c\n\x05\x04\x07\x02\x03\x01\x12\x037\x16&\n\x0c\n\x05\x04\
    \x07\x02\x03\x03\x12\x037)*\n\n\n\x02\x04\x08\x12\x04:\0?\x01\n\n\n\x03\
    \x04\x08\x01\x12\x03:\x08-\n\x0b\n\x04\x04\x08\x02\0\x12\x03;\x08%\n\x0c\
    \n\x05\x04\x08\x02\0\x04\x12\x03;\x08\x10\n\x0c\n\x05\x04\x08\x02\0\x05\
    \x12\x03;\x11\x18\n\x0c\n\x05\x04\x08\x02\0\x01\x12\x03;\x19\x20\n\x0c\n\
    \x05\x04\x08\x02\0\x03\x12\x03;#$\n\x0b\n\x04\x04\x08\x02\x01\x12\x03<\
    \x08&\n\x0c\n\x05\x04\x08\x02\x01\x04\x12\x03<\x08\x10\n\x0c\n\x05\x04\
    \x08\x02\x01\x05\x12\x03<\x11\x18\n\x0c\n\x05\x04\x08\x02\x01\x01\x12\
    \x03<\x19!\n\x0c\n\x05\x04\x08\x02\x01\x03\x12\x03<$%\n\x0b\n\x04\x04\
    \x08\x02\x02\x12\x03=\x08(\n\x0c\n\x05\x04\x08\x02\x02\x04\x12\x03=\x08\
    \x10\n\x0c\n\x05\x04\x08\x02\x02\x05\x12\x03=\x11\x18\n\x0c\n\x05\x04\
    \x08\x02\x02\x01\x12\x03=\x19#\n\x0c\n\x05\x04\x08\x02\x02\x03\x12\x03=&\
    '\n\x0b\n\x04\x04\x08\x02\x03\x12\x03>\x08)\n\x0c\n\x05\x04\x08\x02\x03\
    \x04\x12\x03>\x08\x10\n\x0c\n\x05\x04\x08\x02\x03\x05\x12\x03>\x11\x17\n\
    \x0c\n\x05\x04\x08\x02\x03\x01\x12\x03>\x18$\n\x0c\n\x05\x04\x08\x02\x03\
    \x03\x12\x03>'(\n\n\n\x02\x04\t\x12\x04A\0B\x01\n\n\n\x03\x04\t\x01\x12\
    \x03A\x08.\n\n\n\x02\x04\n\x12\x04D\0H\x01\n\n\n\x03\x04\n\x01\x12\x03D\
    \x08/\n\x0b\n\x04\x04\n\x02\0\x12\x03E\x08%\n\x0c\n\x05\x04\n\x02\0\x04\
    \x12\x03E\x08\x10\n\x0c\n\x05\x04\n\x02\0\x05\x12\x03E\x11\x18\n\x0c\n\
    \x05\x04\n\x02\0\x01\x12\x03E\x19\x20\n\x0c\n\x05\x04\n\x02\0\x03\x12\
    \x03E#$\n\x0b\n\x04\x04\n\x02\x01\x12\x03F\x08(\n\x0c\n\x05\x04\n\x02\
    \x01\x04\x12\x03F\x08\x10\n\x0c\n\x05\x04\n\x02\x01\x05\x12\x03F\x11\x18\
    \n\x0c\n\x05\x04\n\x02\x01\x01\x12\x03F\x19#\n\x0c\n\x05\x04\n\x02\x01\
    \x03\x12\x03F&'\n\x0b\n\x04\x04\n\x02\x02\x12\x03G\x08\"\n\x0c\n\x05\x04\
    \n\x02\x02\x04\x12\x03G\x08\x10\n\x0c\n\x05\x04\n\x02\x02\x05\x12\x03G\
    \x11\x17\n\x0c\n\x05\x04\n\x02\x02\x01\x12\x03G\x18\x1d\n\x0c\n\x05\x04\
    \n\x02\x02\x03\x12\x03G\x20!\n\n\n\x02\x04\x0b\x12\x04J\0K\x01\n\n\n\x03\
    \x04\x0b\x01\x12\x03J\x080\n\n\n\x02\x04\x0c\x12\x04M\0Q\x01\n\n\n\x03\
    \x04\x0c\x01\x12\x03M\x084\n\x0b\n\x04\x04\x0c\x02\0\x12\x03N\x08%\n\x0c\
    \n\x05\x04\x0c\x02\0\x04\x12\x03N\x08\x10\n\x0c\n\x05\x04\x0c\x02\0\x05\
    \x12\x03N\x11\x18\n\x0c\n\x05\x04\x0c\x02\0\x01\x12\x03N\x19\x20\n\x0c\n\
    \x05\x04\x0c\x02\0\x03\x12\x03N#$\n\x0b\n\x04\x04\x0c\x02\x01\x12\x03O\
    \x08(\n\x0c\n\x05\x04\x0c\x02\x01\x04\x12\x03O\x08\x10\n\x0c\n\x05\x04\
    \x0c\x02\x01\x05\x12\x03O\x11\x18\n\x0c\n\x05\x04\x0c\x02\x01\x01\x12\
    \x03O\x19#\n\x0c\n\x05\x04\x0c\x02\x01\x03\x12\x03O&'\n\x0b\n\x04\x04\
    \x0c\x02\x02\x12\x03P\x08\"\n\x0c\n\x05\x04\x0c\x02\x02\x04\x12\x03P\x08\
    \x10\n\x0c\n\x05\x04\x0c\x02\x02\x05\x12\x03P\x11\x17\n\x0c\n\x05\x04\
    \x0c\x02\x02\x01\x12\x03P\x18\x1d\n\x0c\n\x05\x04\x0c\x02\x02\x03\x12\
    \x03P\x20!\n\n\n\x02\x04\r\x12\x04S\0U\x01\n\n\n\x03\x04\r\x01\x12\x03S\
    \x085\n\x0b\n\x04\x04\r\x02\0\x12\x03T\x08,\n\x0c\n\x05\x04\r\x02\0\x04\
    \x12\x03T\x08\x10\n\x0c\n\x05\x04\r\x02\0\x05\x12\x03T\x11\x17\n\x0c\n\
    \x05\x04\r\x02\0\x01\x12\x03T\x18'\n\x0c\n\x05\x04\r\x02\0\x03\x12\x03T*\
    +\n\n\n\x02\x06\0\x12\x04W\0f\x01\n\n\n\x03\x06\0\x01\x12\x03W\x08\x19\n\
    \n\n\x03\x06\0\x03\x12\x03X\x08K\n\r\n\x06\x06\0\x03\xd0\x86\x03\x12\x03\
    X\x08K\n\n\n\x03\x06\0\x03\x12\x03Y\x08K\n\r\n\x06\x06\0\x03\xd8\x86\x03\
    \x12\x03Y\x08K\n\x0c\n\x04\x06\0\x02\0\x12\x04[\x08]\t\n\x0c\n\x05\x06\0\
    \x02\0\x01\x12\x03[\x0c\x1a\n\x0c\n\x05\x06\0\x02\0\x02\x12\x03[\x1cF\n\
    \x0c\n\x05\x06\0\x02\0\x03\x12\x03[Q|\n\x0c\n\x05\x06\0\x02\0\x04\x12\
    \x03\\\x10q\n\x0f\n\x08\x06\0\x02\0\x04\xd0\x86\x03\x12\x03\\\x10q\n\x0c\
    \n\x04\x06\0\x02\x01\x12\x04_\x08a\t\n\x0c\n\x05\x06\0\x02\x01\x01\x12\
    \x03_\x0c*\n\x0c\n\x05\x06\0\x02\x01\x02\x12\x03_,Y\n\x0c\n\x05\x06\0\
    \x02\x01\x03\x12\x03_do\n\x0c\n\x05\x06\0\x02\x01\x04\x12\x03`\x10b\n\
    \x0f\n\x08\x06\0\x02\x01\x04\xd0\x86\x03\x12\x03`\x10b\n\x0c\n\x04\x06\0\
    \x02\x02\x12\x04c\x08e\t\n\x0c\n\x05\x06\0\x02\x02\x01\x12\x03c\x0c'\n\
    \x0c\n\x05\x06\0\x02\x02\x02\x12\x03c)Y\n\x0c\n\x05\x06\0\x02\x02\x03\
    \x12\x03cdo\n\x0c\n\x05\x06\0\x02\x02\x04\x12\x03d\x10i\n\x0f\n\x08\x06\
    \0\x02\x02\x04\xd0\x86\x03\x12\x03d\x10i\n\n\n\x02\x06\x01\x12\x04h\0~\
    \x01\n\n\n\x03\x06\x01\x01\x12\x03h\x08\x13\n\n\n\x03\x06\x01\x03\x12\
    \x03i\x08>\n\r\n\x06\x06\x01\x03\xd0\x86\x03\x12\x03i\x08>\n\x0c\n\x04\
    \x06\x01\x02\0\x12\x04k\x08m\t\n\x0c\n\x05\x06\x01\x02\0\x01\x12\x03k\
    \x0c\x1f\n\x0c\n\x05\x06\x01\x02\0\x02\x12\x03k!J\n\x0c\n\x05\x06\x01\
    \x02\0\x03\x12\x03kU\x7f\n\x0c\n\x05\x06\x01\x02\0\x04\x12\x03l\x10c\n\
    \x0f\n\x08\x06\x01\x02\0\x04\xd0\x86\x03\x12\x03l\x10c\n\x0c\n\x04\x06\
    \x01\x02\x01\x12\x04o\x08q\t\n\x0c\n\x05\x06\x01\x02\x01\x01\x12\x03o\
    \x0c\x1b\n\x0c\n\x05\x06\x01\x02\x01\x02\x12\x03o\x1dB\n\x0c\n\x05\x06\
    \x01\x02\x01\x03\x12\x03oMs\n\x0c\n\x05\x06\x01\x02\x01\x04\x12\x03p\x10\
    Q\n\x0f\n\x08\x06\x01\x02\x01\x04\xd0\x86\x03\x12\x03p\x10Q\n\x0c\n\x04\
    \x06\x01\x02\x02\x12\x04s\x08u\t\n\x0c\n\x05\x06\x01\x02\x02\x01\x12\x03\
    s\x0c\x1c\n\x0c\n\x05\x06\x01\x02\x02\x02\x12\x03s\x1eD\n\x0c\n\x05\x06\
    \x01\x02\x02\x03\x12\x03sOv\n\x0c\n\x05\x06\x01\x02\x02\x04\x12\x03t\x10\
    e\n\x0f\n\x08\x06\x01\x02\x02\x04\xd0\x86\x03\x12\x03t\x10e\n\x0c\n\x04\
    \x06\x01\x02\x03\x12\x04w\x08y\t\n\x0c\n\x05\x06\x01\x02\x03\x01\x12\x03\
    w\x0c\x1e\n\x0c\n\x05\x06\x01\x02\x03\x02\x12\x03w\x20H\n\x0c\n\x05\x06\
    \x01\x02\x03\x03\x12\x03wS|\n\x0c\n\x05\x06\x01\x02\x03\x04\x12\x03x\x10\
    `\n\x0f\n\x08\x06\x01\x02\x03\x04\xd0\x86\x03\x12\x03x\x10`\n\x0c\n\x04\
    \x06\x01\x02\x04\x12\x04{\x08}\t\n\x0c\n\x05\x06\x01\x02\x04\x01\x12\x03\
    {\x0c#\n\x0c\n\x05\x06\x01\x02\x04\x02\x12\x03{%R\n\r\n\x05\x06\x01\x02\
    \x04\x03\x12\x04{]\x8b\x01\n\x0c\n\x05\x06\x01\x02\x04\x04\x12\x03|\x10m\
    \n\x0f\n\x08\x06\x01\x02\x04\x04\xd0\x86\x03\x12\x03|\x10m\
";

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

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

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