#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![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)]
#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CSiteManagerClient_IncomingClient_Request {
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>>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
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()
}
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()
}
pub fn set_site_instanceid(&mut self, v: u64) {
self.site_instanceid = ::std::option::Option::Some(v);
}
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()
}
pub fn set_client_steamid(&mut self, v: u64) {
self.client_steamid = ::std::option::Option::Some(v);
}
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()
}
pub fn set_client_local_ip(&mut self, v: u32) {
self.client_local_ip = ::std::option::Option::Some(v);
}
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()
}
pub fn set_connection_key(&mut self, v: ::std::vec::Vec<u8>) {
self.connection_key = ::protobuf::SingularField::some(v);
}
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()
}
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(())
}
#[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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CSiteManagerClient_IncomingClient_Response {
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
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(())
}
#[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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CSiteLicense_ClientSeatCheckout_Notification {
appid: ::std::option::Option<u32>,
eresult: ::std::option::Option<u32>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
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()
}
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()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
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()
}
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(())
}
#[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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CSiteManagerClient_TrackedPayments_Notification {
site_id: ::std::option::Option<u64>,
pub payments: ::protobuf::RepeatedField<CSiteManagerClient_TrackedPayments_Notification_Payment>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
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()
}
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()
}
pub fn set_site_id(&mut self, v: u64) {
self.site_id = ::std::option::Option::Some(v);
}
pub fn get_payments(&self) -> &[CSiteManagerClient_TrackedPayments_Notification_Payment] {
&self.payments
}
pub fn clear_payments(&mut self) {
self.payments.clear();
}
pub fn set_payments(&mut self, v: ::protobuf::RepeatedField<CSiteManagerClient_TrackedPayments_Notification_Payment>) {
self.payments = v;
}
pub fn mut_payments(&mut self) -> &mut ::protobuf::RepeatedField<CSiteManagerClient_TrackedPayments_Notification_Payment> {
&mut self.payments
}
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(())
}
#[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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CSiteManagerClient_TrackedPayments_Notification_Payment {
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>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
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()
}
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()
}
pub fn set_transid(&mut self, v: u64) {
self.transid = ::std::option::Option::Some(v);
}
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()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
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()
}
pub fn set_amount(&mut self, v: i64) {
self.amount = ::std::option::Option::Some(v);
}
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()
}
pub fn set_ecurrency(&mut self, v: u32) {
self.ecurrency = ::std::option::Option::Some(v);
}
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()
}
pub fn set_time_created(&mut self, v: i32) {
self.time_created = ::std::option::Option::Some(v);
}
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()
}
pub fn set_purchase_status(&mut self, v: i32) {
self.purchase_status = ::std::option::Option::Some(v);
}
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()
}
pub fn set_machine_name(&mut self, v: ::std::string::String) {
self.machine_name = ::protobuf::SingularField::some(v);
}
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()
}
pub fn take_machine_name(&mut self) -> ::std::string::String {
self.machine_name.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_persona_name(&mut self, v: ::std::string::String) {
self.persona_name = ::protobuf::SingularField::some(v);
}
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()
}
pub fn take_persona_name(&mut self) -> ::std::string::String {
self.persona_name.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_profile_url(&mut self, v: ::std::string::String) {
self.profile_url = ::protobuf::SingularField::some(v);
}
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()
}
pub fn take_profile_url(&mut self) -> ::std::string::String {
self.profile_url.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_avatar_url(&mut self, v: ::std::string::String) {
self.avatar_url = ::protobuf::SingularField::some(v);
}
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()
}
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(())
}
#[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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CSiteLicense_InitiateAssociation_Request {
site_steamid: ::std::option::Option<u64>,
site_instanceid: ::std::option::Option<u64>,
client_local_ip: ::std::option::Option<u32>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
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()
}
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()
}
pub fn set_site_steamid(&mut self, v: u64) {
self.site_steamid = ::std::option::Option::Some(v);
}
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()
}
pub fn set_site_instanceid(&mut self, v: u64) {
self.site_instanceid = ::std::option::Option::Some(v);
}
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()
}
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(())
}
#[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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CSiteLicense_InitiateAssociation_Response {
connection_key: ::protobuf::SingularField<::std::vec::Vec<u8>>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
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()
}
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()
}
pub fn set_connection_key(&mut self, v: ::std::vec::Vec<u8>) {
self.connection_key = ::protobuf::SingularField::some(v);
}
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()
}
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(())
}
#[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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CSiteLicense_LCSAuthenticate_Request {
instanceid: ::std::option::Option<u64>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
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()
}
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()
}
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(())
}
#[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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CSiteLicense_LCSAuthenticate_Response {
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>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
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()
}
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()
}
pub fn set_site_id(&mut self, v: u64) {
self.site_id = ::std::option::Option::Some(v);
}
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()
}
pub fn set_site_name(&mut self, v: ::std::string::String) {
self.site_name = ::protobuf::SingularField::some(v);
}
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()
}
pub fn take_site_name(&mut self) -> ::std::string::String {
self.site_name.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_new_session(&mut self, v: bool) {
self.new_session = ::std::option::Option::Some(v);
}
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()
}
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(())
}
#[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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CSiteLicense_LCSAssociateUser_Request {
steamid: ::std::option::Option<u64>,
local_ip: ::std::option::Option<u32>,
instanceid: ::std::option::Option<u64>,
machine_name: ::protobuf::SingularField<::std::string::String>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
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()
}
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()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
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()
}
pub fn set_local_ip(&mut self, v: u32) {
self.local_ip = ::std::option::Option::Some(v);
}
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()
}
pub fn set_instanceid(&mut self, v: u64) {
self.instanceid = ::std::option::Option::Some(v);
}
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()
}
pub fn set_machine_name(&mut self, v: ::std::string::String) {
self.machine_name = ::protobuf::SingularField::some(v);
}
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()
}
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(())
}
#[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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CSiteLicense_LCSAssociateUser_Response {
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
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(())
}
#[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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CSiteLicense_ClientSeatCheckout_Request {
steamid: ::std::option::Option<u64>,
instanceid: ::std::option::Option<u64>,
appid: ::std::option::Option<u32>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
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()
}
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()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
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()
}
pub fn set_instanceid(&mut self, v: u64) {
self.instanceid = ::std::option::Option::Some(v);
}
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()
}
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(())
}
#[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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CSiteLicense_ClientSeatCheckout_Response {
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
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(())
}
#[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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CSiteLicense_ClientGetAvailableSeats_Request {
steamid: ::std::option::Option<u64>,
instanceid: ::std::option::Option<u64>,
appid: ::std::option::Option<u32>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
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()
}
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()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
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()
}
pub fn set_instanceid(&mut self, v: u64) {
self.instanceid = ::std::option::Option::Some(v);
}
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()
}
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(())
}
#[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)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CSiteLicense_ClientGetAvailableSeats_Response {
available_seats: ::std::option::Option<u32>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
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()
}
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()
}
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(())
}
#[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\x01\
";
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()
})
}