steam-protobuf 0.1.2

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

// https://github.com/rust-lang/rust-clippy/issues/702
#![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)]
//! Generated file from `steammessages_parental.steamclient.proto`

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

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct ParentalApp {
    // message fields
    appid: ::std::option::Option<u32>,
    is_allowed: ::std::option::Option<bool>,
    // special fields
    #[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 ParentalApp {
    fn default() -> &'a ParentalApp {
        <ParentalApp as ::protobuf::Message>::default_instance()
    }
}

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

    // optional uint32 appid = 1;


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

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

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

    // optional bool is_allowed = 2;


    pub fn get_is_allowed(&self) -> bool {
        self.is_allowed.unwrap_or(false)
    }
    pub fn clear_is_allowed(&mut self) {
        self.is_allowed = ::std::option::Option::None;
    }

    pub fn has_is_allowed(&self) -> bool {
        self.is_allowed.is_some()
    }

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

impl ::protobuf::Message for ParentalApp {
    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_bool()?;
                    self.is_allowed = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.is_allowed {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.is_allowed {
            os.write_bool(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() -> ParentalApp {
        ParentalApp::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: &ParentalApp| { &m.appid },
                |m: &mut ParentalApp| { &mut m.appid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_allowed",
                |m: &ParentalApp| { &m.is_allowed },
                |m: &mut ParentalApp| { &mut m.is_allowed },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ParentalApp>(
                "ParentalApp",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for ParentalApp {
    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 ParentalSettings {
    // message fields
    steamid: ::std::option::Option<u64>,
    applist_base_id: ::std::option::Option<u32>,
    applist_base_description: ::protobuf::SingularField<::std::string::String>,
    pub applist_base: ::protobuf::RepeatedField<ParentalApp>,
    pub applist_custom: ::protobuf::RepeatedField<ParentalApp>,
    passwordhashtype: ::std::option::Option<u32>,
    salt: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    passwordhash: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    is_enabled: ::std::option::Option<bool>,
    enabled_features: ::std::option::Option<u32>,
    recovery_email: ::protobuf::SingularField<::std::string::String>,
    is_site_license_lock: ::std::option::Option<bool>,
    // special fields
    #[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 ParentalSettings {
    fn default() -> &'a ParentalSettings {
        <ParentalSettings as ::protobuf::Message>::default_instance()
    }
}

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

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

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

    // optional uint32 applist_base_id = 2;


    pub fn get_applist_base_id(&self) -> u32 {
        self.applist_base_id.unwrap_or(0)
    }
    pub fn clear_applist_base_id(&mut self) {
        self.applist_base_id = ::std::option::Option::None;
    }

    pub fn has_applist_base_id(&self) -> bool {
        self.applist_base_id.is_some()
    }

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

    // optional string applist_base_description = 3;


    pub fn get_applist_base_description(&self) -> &str {
        match self.applist_base_description.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_applist_base_description(&mut self) {
        self.applist_base_description.clear();
    }

    pub fn has_applist_base_description(&self) -> bool {
        self.applist_base_description.is_some()
    }

    // Param is passed by value, moved
    pub fn set_applist_base_description(&mut self, v: ::std::string::String) {
        self.applist_base_description = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_applist_base_description(&mut self) -> &mut ::std::string::String {
        if self.applist_base_description.is_none() {
            self.applist_base_description.set_default();
        }
        self.applist_base_description.as_mut().unwrap()
    }

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

    // repeated .ParentalApp applist_base = 4;


    pub fn get_applist_base(&self) -> &[ParentalApp] {
        &self.applist_base
    }
    pub fn clear_applist_base(&mut self) {
        self.applist_base.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_applist_base(&mut self) -> &mut ::protobuf::RepeatedField<ParentalApp> {
        &mut self.applist_base
    }

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

    // repeated .ParentalApp applist_custom = 5;


    pub fn get_applist_custom(&self) -> &[ParentalApp] {
        &self.applist_custom
    }
    pub fn clear_applist_custom(&mut self) {
        self.applist_custom.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_applist_custom(&mut self) -> &mut ::protobuf::RepeatedField<ParentalApp> {
        &mut self.applist_custom
    }

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

    // optional uint32 passwordhashtype = 6;


    pub fn get_passwordhashtype(&self) -> u32 {
        self.passwordhashtype.unwrap_or(0)
    }
    pub fn clear_passwordhashtype(&mut self) {
        self.passwordhashtype = ::std::option::Option::None;
    }

    pub fn has_passwordhashtype(&self) -> bool {
        self.passwordhashtype.is_some()
    }

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

    // optional bytes salt = 7;


    pub fn get_salt(&self) -> &[u8] {
        match self.salt.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_salt(&mut self) {
        self.salt.clear();
    }

    pub fn has_salt(&self) -> bool {
        self.salt.is_some()
    }

    // Param is passed by value, moved
    pub fn set_salt(&mut self, v: ::std::vec::Vec<u8>) {
        self.salt = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_salt(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.salt.is_none() {
            self.salt.set_default();
        }
        self.salt.as_mut().unwrap()
    }

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

    // optional bytes passwordhash = 8;


    pub fn get_passwordhash(&self) -> &[u8] {
        match self.passwordhash.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_passwordhash(&mut self) {
        self.passwordhash.clear();
    }

    pub fn has_passwordhash(&self) -> bool {
        self.passwordhash.is_some()
    }

    // Param is passed by value, moved
    pub fn set_passwordhash(&mut self, v: ::std::vec::Vec<u8>) {
        self.passwordhash = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_passwordhash(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.passwordhash.is_none() {
            self.passwordhash.set_default();
        }
        self.passwordhash.as_mut().unwrap()
    }

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

    // optional bool is_enabled = 9;


    pub fn get_is_enabled(&self) -> bool {
        self.is_enabled.unwrap_or(false)
    }
    pub fn clear_is_enabled(&mut self) {
        self.is_enabled = ::std::option::Option::None;
    }

    pub fn has_is_enabled(&self) -> bool {
        self.is_enabled.is_some()
    }

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

    // optional uint32 enabled_features = 10;


    pub fn get_enabled_features(&self) -> u32 {
        self.enabled_features.unwrap_or(0)
    }
    pub fn clear_enabled_features(&mut self) {
        self.enabled_features = ::std::option::Option::None;
    }

    pub fn has_enabled_features(&self) -> bool {
        self.enabled_features.is_some()
    }

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

    // optional string recovery_email = 11;


    pub fn get_recovery_email(&self) -> &str {
        match self.recovery_email.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_recovery_email(&mut self) {
        self.recovery_email.clear();
    }

    pub fn has_recovery_email(&self) -> bool {
        self.recovery_email.is_some()
    }

    // Param is passed by value, moved
    pub fn set_recovery_email(&mut self, v: ::std::string::String) {
        self.recovery_email = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_recovery_email(&mut self) -> &mut ::std::string::String {
        if self.recovery_email.is_none() {
            self.recovery_email.set_default();
        }
        self.recovery_email.as_mut().unwrap()
    }

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

    // optional bool is_site_license_lock = 12;


    pub fn get_is_site_license_lock(&self) -> bool {
        self.is_site_license_lock.unwrap_or(false)
    }
    pub fn clear_is_site_license_lock(&mut self) {
        self.is_site_license_lock = ::std::option::Option::None;
    }

    pub fn has_is_site_license_lock(&self) -> bool {
        self.is_site_license_lock.is_some()
    }

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

impl ::protobuf::Message for ParentalSettings {
    fn is_initialized(&self) -> bool {
        for v in &self.applist_base {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.applist_custom {
            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.steamid = ::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.applist_base_id = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.applist_base_description)?;
                },
                4 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.applist_base)?;
                },
                5 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.applist_custom)?;
                },
                6 => {
                    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.passwordhashtype = ::std::option::Option::Some(tmp);
                },
                7 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.salt)?;
                },
                8 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.passwordhash)?;
                },
                9 => {
                    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.is_enabled = ::std::option::Option::Some(tmp);
                },
                10 => {
                    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.enabled_features = ::std::option::Option::Some(tmp);
                },
                11 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.recovery_email)?;
                },
                12 => {
                    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.is_site_license_lock = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.steamid {
            my_size += 9;
        }
        if let Some(v) = self.applist_base_id {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.applist_base_description.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        for value in &self.applist_base {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in &self.applist_custom {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(v) = self.passwordhashtype {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.salt.as_ref() {
            my_size += ::protobuf::rt::bytes_size(7, &v);
        }
        if let Some(ref v) = self.passwordhash.as_ref() {
            my_size += ::protobuf::rt::bytes_size(8, &v);
        }
        if let Some(v) = self.is_enabled {
            my_size += 2;
        }
        if let Some(v) = self.enabled_features {
            my_size += ::protobuf::rt::value_size(10, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.recovery_email.as_ref() {
            my_size += ::protobuf::rt::string_size(11, &v);
        }
        if let Some(v) = self.is_site_license_lock {
            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.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.applist_base_id {
            os.write_uint32(2, v)?;
        }
        if let Some(ref v) = self.applist_base_description.as_ref() {
            os.write_string(3, &v)?;
        }
        for v in &self.applist_base {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        for v in &self.applist_custom {
            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(v) = self.passwordhashtype {
            os.write_uint32(6, v)?;
        }
        if let Some(ref v) = self.salt.as_ref() {
            os.write_bytes(7, &v)?;
        }
        if let Some(ref v) = self.passwordhash.as_ref() {
            os.write_bytes(8, &v)?;
        }
        if let Some(v) = self.is_enabled {
            os.write_bool(9, v)?;
        }
        if let Some(v) = self.enabled_features {
            os.write_uint32(10, v)?;
        }
        if let Some(ref v) = self.recovery_email.as_ref() {
            os.write_string(11, &v)?;
        }
        if let Some(v) = self.is_site_license_lock {
            os.write_bool(12, 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() -> ParentalSettings {
        ParentalSettings::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: &ParentalSettings| { &m.steamid },
                |m: &mut ParentalSettings| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "applist_base_id",
                |m: &ParentalSettings| { &m.applist_base_id },
                |m: &mut ParentalSettings| { &mut m.applist_base_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "applist_base_description",
                |m: &ParentalSettings| { &m.applist_base_description },
                |m: &mut ParentalSettings| { &mut m.applist_base_description },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ParentalApp>>(
                "applist_base",
                |m: &ParentalSettings| { &m.applist_base },
                |m: &mut ParentalSettings| { &mut m.applist_base },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ParentalApp>>(
                "applist_custom",
                |m: &ParentalSettings| { &m.applist_custom },
                |m: &mut ParentalSettings| { &mut m.applist_custom },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "passwordhashtype",
                |m: &ParentalSettings| { &m.passwordhashtype },
                |m: &mut ParentalSettings| { &mut m.passwordhashtype },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "salt",
                |m: &ParentalSettings| { &m.salt },
                |m: &mut ParentalSettings| { &mut m.salt },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "passwordhash",
                |m: &ParentalSettings| { &m.passwordhash },
                |m: &mut ParentalSettings| { &mut m.passwordhash },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_enabled",
                |m: &ParentalSettings| { &m.is_enabled },
                |m: &mut ParentalSettings| { &mut m.is_enabled },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "enabled_features",
                |m: &ParentalSettings| { &m.enabled_features },
                |m: &mut ParentalSettings| { &mut m.enabled_features },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "recovery_email",
                |m: &ParentalSettings| { &m.recovery_email },
                |m: &mut ParentalSettings| { &mut m.recovery_email },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_site_license_lock",
                |m: &ParentalSettings| { &m.is_site_license_lock },
                |m: &mut ParentalSettings| { &mut m.is_site_license_lock },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ParentalSettings>(
                "ParentalSettings",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ParentalSettings {
    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.applist_base_id = ::std::option::Option::None;
        self.applist_base_description.clear();
        self.applist_base.clear();
        self.applist_custom.clear();
        self.passwordhashtype = ::std::option::Option::None;
        self.salt.clear();
        self.passwordhash.clear();
        self.is_enabled = ::std::option::Option::None;
        self.enabled_features = ::std::option::Option::None;
        self.recovery_email.clear();
        self.is_site_license_lock = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for ParentalSettings {
    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 CParental_EnableParentalSettings_Request {
    // message fields
    password: ::protobuf::SingularField<::std::string::String>,
    pub settings: ::protobuf::SingularPtrField<ParentalSettings>,
    sessionid: ::protobuf::SingularField<::std::string::String>,
    enablecode: ::std::option::Option<u32>,
    steamid: ::std::option::Option<u64>,
    // special fields
    #[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 CParental_EnableParentalSettings_Request {
    fn default() -> &'a CParental_EnableParentalSettings_Request {
        <CParental_EnableParentalSettings_Request as ::protobuf::Message>::default_instance()
    }
}

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

    // optional string password = 1;


    pub fn get_password(&self) -> &str {
        match self.password.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_password(&mut self) {
        self.password.clear();
    }

    pub fn has_password(&self) -> bool {
        self.password.is_some()
    }

    // Param is passed by value, moved
    pub fn set_password(&mut self, v: ::std::string::String) {
        self.password = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_password(&mut self) -> &mut ::std::string::String {
        if self.password.is_none() {
            self.password.set_default();
        }
        self.password.as_mut().unwrap()
    }

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

    // optional .ParentalSettings settings = 2;


    pub fn get_settings(&self) -> &ParentalSettings {
        self.settings.as_ref().unwrap_or_else(|| <ParentalSettings as ::protobuf::Message>::default_instance())
    }
    pub fn clear_settings(&mut self) {
        self.settings.clear();
    }

    pub fn has_settings(&self) -> bool {
        self.settings.is_some()
    }

    // Param is passed by value, moved
    pub fn set_settings(&mut self, v: ParentalSettings) {
        self.settings = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_settings(&mut self) -> &mut ParentalSettings {
        if self.settings.is_none() {
            self.settings.set_default();
        }
        self.settings.as_mut().unwrap()
    }

    // Take field
    pub fn take_settings(&mut self) -> ParentalSettings {
        self.settings.take().unwrap_or_else(|| ParentalSettings::new())
    }

    // optional string sessionid = 3;


    pub fn get_sessionid(&self) -> &str {
        match self.sessionid.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_sessionid(&mut self) {
        self.sessionid.clear();
    }

    pub fn has_sessionid(&self) -> bool {
        self.sessionid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_sessionid(&mut self, v: ::std::string::String) {
        self.sessionid = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_sessionid(&mut self) -> &mut ::std::string::String {
        if self.sessionid.is_none() {
            self.sessionid.set_default();
        }
        self.sessionid.as_mut().unwrap()
    }

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

    // optional uint32 enablecode = 4;


    pub fn get_enablecode(&self) -> u32 {
        self.enablecode.unwrap_or(0)
    }
    pub fn clear_enablecode(&mut self) {
        self.enablecode = ::std::option::Option::None;
    }

    pub fn has_enablecode(&self) -> bool {
        self.enablecode.is_some()
    }

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

    // optional fixed64 steamid = 10;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

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

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

impl ::protobuf::Message for CParental_EnableParentalSettings_Request {
    fn is_initialized(&self) -> bool {
        for v in &self.settings {
            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 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.password)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.settings)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.sessionid)?;
                },
                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.enablecode = ::std::option::Option::Some(tmp);
                },
                10 => {
                    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);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.password.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.settings.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.sessionid.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.enablecode {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.steamid {
            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(ref v) = self.password.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.settings.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.sessionid.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(v) = self.enablecode {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_fixed64(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() -> CParental_EnableParentalSettings_Request {
        CParental_EnableParentalSettings_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "password",
                |m: &CParental_EnableParentalSettings_Request| { &m.password },
                |m: &mut CParental_EnableParentalSettings_Request| { &mut m.password },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ParentalSettings>>(
                "settings",
                |m: &CParental_EnableParentalSettings_Request| { &m.settings },
                |m: &mut CParental_EnableParentalSettings_Request| { &mut m.settings },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "sessionid",
                |m: &CParental_EnableParentalSettings_Request| { &m.sessionid },
                |m: &mut CParental_EnableParentalSettings_Request| { &mut m.sessionid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "enablecode",
                |m: &CParental_EnableParentalSettings_Request| { &m.enablecode },
                |m: &mut CParental_EnableParentalSettings_Request| { &mut m.enablecode },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "steamid",
                |m: &CParental_EnableParentalSettings_Request| { &m.steamid },
                |m: &mut CParental_EnableParentalSettings_Request| { &mut m.steamid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_EnableParentalSettings_Request>(
                "CParental_EnableParentalSettings_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CParental_EnableParentalSettings_Request {
    fn clear(&mut self) {
        self.password.clear();
        self.settings.clear();
        self.sessionid.clear();
        self.enablecode = ::std::option::Option::None;
        self.steamid = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for CParental_EnableParentalSettings_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 CParental_EnableParentalSettings_Response {
    // special fields
    #[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 CParental_EnableParentalSettings_Response {
    fn default() -> &'a CParental_EnableParentalSettings_Response {
        <CParental_EnableParentalSettings_Response as ::protobuf::Message>::default_instance()
    }
}

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

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

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

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

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

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

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

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

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

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

    fn new() -> CParental_EnableParentalSettings_Response {
        CParental_EnableParentalSettings_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::<CParental_EnableParentalSettings_Response>(
                "CParental_EnableParentalSettings_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_EnableParentalSettings_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 CParental_DisableParentalSettings_Request {
    // message fields
    password: ::protobuf::SingularField<::std::string::String>,
    steamid: ::std::option::Option<u64>,
    // special fields
    #[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 CParental_DisableParentalSettings_Request {
    fn default() -> &'a CParental_DisableParentalSettings_Request {
        <CParental_DisableParentalSettings_Request as ::protobuf::Message>::default_instance()
    }
}

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

    // optional string password = 1;


    pub fn get_password(&self) -> &str {
        match self.password.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_password(&mut self) {
        self.password.clear();
    }

    pub fn has_password(&self) -> bool {
        self.password.is_some()
    }

    // Param is passed by value, moved
    pub fn set_password(&mut self, v: ::std::string::String) {
        self.password = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_password(&mut self) -> &mut ::std::string::String {
        if self.password.is_none() {
            self.password.set_default();
        }
        self.password.as_mut().unwrap()
    }

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

    // optional fixed64 steamid = 10;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

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

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

impl ::protobuf::Message for CParental_DisableParentalSettings_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 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.password)?;
                },
                10 => {
                    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);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.password.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.steamid {
            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(ref v) = self.password.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(v) = self.steamid {
            os.write_fixed64(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() -> CParental_DisableParentalSettings_Request {
        CParental_DisableParentalSettings_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "password",
                |m: &CParental_DisableParentalSettings_Request| { &m.password },
                |m: &mut CParental_DisableParentalSettings_Request| { &mut m.password },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "steamid",
                |m: &CParental_DisableParentalSettings_Request| { &m.steamid },
                |m: &mut CParental_DisableParentalSettings_Request| { &mut m.steamid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_DisableParentalSettings_Request>(
                "CParental_DisableParentalSettings_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_DisableParentalSettings_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 CParental_DisableParentalSettings_Response {
    // special fields
    #[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 CParental_DisableParentalSettings_Response {
    fn default() -> &'a CParental_DisableParentalSettings_Response {
        <CParental_DisableParentalSettings_Response as ::protobuf::Message>::default_instance()
    }
}

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

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

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

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

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

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

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

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

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

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

    fn new() -> CParental_DisableParentalSettings_Response {
        CParental_DisableParentalSettings_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::<CParental_DisableParentalSettings_Response>(
                "CParental_DisableParentalSettings_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_DisableParentalSettings_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 CParental_GetParentalSettings_Request {
    // message fields
    steamid: ::std::option::Option<u64>,
    // special fields
    #[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 CParental_GetParentalSettings_Request {
    fn default() -> &'a CParental_GetParentalSettings_Request {
        <CParental_GetParentalSettings_Request as ::protobuf::Message>::default_instance()
    }
}

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

    // optional fixed64 steamid = 10;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

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

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

impl ::protobuf::Message for CParental_GetParentalSettings_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 {
                10 => {
                    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);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.steamid {
            my_size += 9;
        }
        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(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() -> CParental_GetParentalSettings_Request {
        CParental_GetParentalSettings_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: &CParental_GetParentalSettings_Request| { &m.steamid },
                |m: &mut CParental_GetParentalSettings_Request| { &mut m.steamid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_GetParentalSettings_Request>(
                "CParental_GetParentalSettings_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_GetParentalSettings_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 CParental_GetParentalSettings_Response {
    // message fields
    pub settings: ::protobuf::SingularPtrField<ParentalSettings>,
    // special fields
    #[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 CParental_GetParentalSettings_Response {
    fn default() -> &'a CParental_GetParentalSettings_Response {
        <CParental_GetParentalSettings_Response as ::protobuf::Message>::default_instance()
    }
}

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

    // optional .ParentalSettings settings = 1;


    pub fn get_settings(&self) -> &ParentalSettings {
        self.settings.as_ref().unwrap_or_else(|| <ParentalSettings as ::protobuf::Message>::default_instance())
    }
    pub fn clear_settings(&mut self) {
        self.settings.clear();
    }

    pub fn has_settings(&self) -> bool {
        self.settings.is_some()
    }

    // Param is passed by value, moved
    pub fn set_settings(&mut self, v: ParentalSettings) {
        self.settings = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_settings(&mut self) -> &mut ParentalSettings {
        if self.settings.is_none() {
            self.settings.set_default();
        }
        self.settings.as_mut().unwrap()
    }

    // Take field
    pub fn take_settings(&mut self) -> ParentalSettings {
        self.settings.take().unwrap_or_else(|| ParentalSettings::new())
    }
}

impl ::protobuf::Message for CParental_GetParentalSettings_Response {
    fn is_initialized(&self) -> bool {
        for v in &self.settings {
            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 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.settings)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.settings.as_ref() {
            let len = v.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(ref v) = self.settings.as_ref() {
            os.write_tag(1, ::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() -> CParental_GetParentalSettings_Response {
        CParental_GetParentalSettings_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_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ParentalSettings>>(
                "settings",
                |m: &CParental_GetParentalSettings_Response| { &m.settings },
                |m: &mut CParental_GetParentalSettings_Response| { &mut m.settings },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_GetParentalSettings_Response>(
                "CParental_GetParentalSettings_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_GetParentalSettings_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 CParental_GetSignedParentalSettings_Request {
    // message fields
    priority: ::std::option::Option<u32>,
    // special fields
    #[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 CParental_GetSignedParentalSettings_Request {
    fn default() -> &'a CParental_GetSignedParentalSettings_Request {
        <CParental_GetSignedParentalSettings_Request as ::protobuf::Message>::default_instance()
    }
}

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

    // optional uint32 priority = 1;


    pub fn get_priority(&self) -> u32 {
        self.priority.unwrap_or(0)
    }
    pub fn clear_priority(&mut self) {
        self.priority = ::std::option::Option::None;
    }

    pub fn has_priority(&self) -> bool {
        self.priority.is_some()
    }

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

impl ::protobuf::Message for CParental_GetSignedParentalSettings_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::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.priority = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.priority {
            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.priority {
            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() -> CParental_GetSignedParentalSettings_Request {
        CParental_GetSignedParentalSettings_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::ProtobufTypeUint32>(
                "priority",
                |m: &CParental_GetSignedParentalSettings_Request| { &m.priority },
                |m: &mut CParental_GetSignedParentalSettings_Request| { &mut m.priority },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_GetSignedParentalSettings_Request>(
                "CParental_GetSignedParentalSettings_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_GetSignedParentalSettings_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 CParental_GetSignedParentalSettings_Response {
    // message fields
    serialized_settings: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    signature: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    #[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 CParental_GetSignedParentalSettings_Response {
    fn default() -> &'a CParental_GetSignedParentalSettings_Response {
        <CParental_GetSignedParentalSettings_Response as ::protobuf::Message>::default_instance()
    }
}

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

    // optional bytes serialized_settings = 1;


    pub fn get_serialized_settings(&self) -> &[u8] {
        match self.serialized_settings.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_serialized_settings(&mut self) {
        self.serialized_settings.clear();
    }

    pub fn has_serialized_settings(&self) -> bool {
        self.serialized_settings.is_some()
    }

    // Param is passed by value, moved
    pub fn set_serialized_settings(&mut self, v: ::std::vec::Vec<u8>) {
        self.serialized_settings = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_serialized_settings(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.serialized_settings.is_none() {
            self.serialized_settings.set_default();
        }
        self.serialized_settings.as_mut().unwrap()
    }

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

    // optional bytes signature = 2;


    pub fn get_signature(&self) -> &[u8] {
        match self.signature.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_signature(&mut self) {
        self.signature.clear();
    }

    pub fn has_signature(&self) -> bool {
        self.signature.is_some()
    }

    // Param is passed by value, moved
    pub fn set_signature(&mut self, v: ::std::vec::Vec<u8>) {
        self.signature = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_signature(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.signature.is_none() {
            self.signature.set_default();
        }
        self.signature.as_mut().unwrap()
    }

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

impl ::protobuf::Message for CParental_GetSignedParentalSettings_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.serialized_settings)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.signature)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.serialized_settings.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(ref v) = self.signature.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &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.serialized_settings.as_ref() {
            os.write_bytes(1, &v)?;
        }
        if let Some(ref v) = self.signature.as_ref() {
            os.write_bytes(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() -> CParental_GetSignedParentalSettings_Response {
        CParental_GetSignedParentalSettings_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>(
                "serialized_settings",
                |m: &CParental_GetSignedParentalSettings_Response| { &m.serialized_settings },
                |m: &mut CParental_GetSignedParentalSettings_Response| { &mut m.serialized_settings },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "signature",
                |m: &CParental_GetSignedParentalSettings_Response| { &m.signature },
                |m: &mut CParental_GetSignedParentalSettings_Response| { &mut m.signature },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_GetSignedParentalSettings_Response>(
                "CParental_GetSignedParentalSettings_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_GetSignedParentalSettings_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 CParental_SetParentalSettings_Request {
    // message fields
    password: ::protobuf::SingularField<::std::string::String>,
    pub settings: ::protobuf::SingularPtrField<ParentalSettings>,
    new_password: ::protobuf::SingularField<::std::string::String>,
    sessionid: ::protobuf::SingularField<::std::string::String>,
    steamid: ::std::option::Option<u64>,
    // special fields
    #[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 CParental_SetParentalSettings_Request {
    fn default() -> &'a CParental_SetParentalSettings_Request {
        <CParental_SetParentalSettings_Request as ::protobuf::Message>::default_instance()
    }
}

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

    // optional string password = 1;


    pub fn get_password(&self) -> &str {
        match self.password.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_password(&mut self) {
        self.password.clear();
    }

    pub fn has_password(&self) -> bool {
        self.password.is_some()
    }

    // Param is passed by value, moved
    pub fn set_password(&mut self, v: ::std::string::String) {
        self.password = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_password(&mut self) -> &mut ::std::string::String {
        if self.password.is_none() {
            self.password.set_default();
        }
        self.password.as_mut().unwrap()
    }

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

    // optional .ParentalSettings settings = 2;


    pub fn get_settings(&self) -> &ParentalSettings {
        self.settings.as_ref().unwrap_or_else(|| <ParentalSettings as ::protobuf::Message>::default_instance())
    }
    pub fn clear_settings(&mut self) {
        self.settings.clear();
    }

    pub fn has_settings(&self) -> bool {
        self.settings.is_some()
    }

    // Param is passed by value, moved
    pub fn set_settings(&mut self, v: ParentalSettings) {
        self.settings = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_settings(&mut self) -> &mut ParentalSettings {
        if self.settings.is_none() {
            self.settings.set_default();
        }
        self.settings.as_mut().unwrap()
    }

    // Take field
    pub fn take_settings(&mut self) -> ParentalSettings {
        self.settings.take().unwrap_or_else(|| ParentalSettings::new())
    }

    // optional string new_password = 3;


    pub fn get_new_password(&self) -> &str {
        match self.new_password.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_new_password(&mut self) {
        self.new_password.clear();
    }

    pub fn has_new_password(&self) -> bool {
        self.new_password.is_some()
    }

    // Param is passed by value, moved
    pub fn set_new_password(&mut self, v: ::std::string::String) {
        self.new_password = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_new_password(&mut self) -> &mut ::std::string::String {
        if self.new_password.is_none() {
            self.new_password.set_default();
        }
        self.new_password.as_mut().unwrap()
    }

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

    // optional string sessionid = 4;


    pub fn get_sessionid(&self) -> &str {
        match self.sessionid.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_sessionid(&mut self) {
        self.sessionid.clear();
    }

    pub fn has_sessionid(&self) -> bool {
        self.sessionid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_sessionid(&mut self, v: ::std::string::String) {
        self.sessionid = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_sessionid(&mut self) -> &mut ::std::string::String {
        if self.sessionid.is_none() {
            self.sessionid.set_default();
        }
        self.sessionid.as_mut().unwrap()
    }

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

    // optional fixed64 steamid = 10;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

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

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

impl ::protobuf::Message for CParental_SetParentalSettings_Request {
    fn is_initialized(&self) -> bool {
        for v in &self.settings {
            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 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.password)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.settings)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.new_password)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.sessionid)?;
                },
                10 => {
                    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);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.password.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.settings.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.new_password.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(ref v) = self.sessionid.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.steamid {
            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(ref v) = self.password.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.settings.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.new_password.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(ref v) = self.sessionid.as_ref() {
            os.write_string(4, &v)?;
        }
        if let Some(v) = self.steamid {
            os.write_fixed64(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() -> CParental_SetParentalSettings_Request {
        CParental_SetParentalSettings_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "password",
                |m: &CParental_SetParentalSettings_Request| { &m.password },
                |m: &mut CParental_SetParentalSettings_Request| { &mut m.password },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ParentalSettings>>(
                "settings",
                |m: &CParental_SetParentalSettings_Request| { &m.settings },
                |m: &mut CParental_SetParentalSettings_Request| { &mut m.settings },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "new_password",
                |m: &CParental_SetParentalSettings_Request| { &m.new_password },
                |m: &mut CParental_SetParentalSettings_Request| { &mut m.new_password },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "sessionid",
                |m: &CParental_SetParentalSettings_Request| { &m.sessionid },
                |m: &mut CParental_SetParentalSettings_Request| { &mut m.sessionid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "steamid",
                |m: &CParental_SetParentalSettings_Request| { &m.steamid },
                |m: &mut CParental_SetParentalSettings_Request| { &mut m.steamid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_SetParentalSettings_Request>(
                "CParental_SetParentalSettings_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CParental_SetParentalSettings_Request {
    fn clear(&mut self) {
        self.password.clear();
        self.settings.clear();
        self.new_password.clear();
        self.sessionid.clear();
        self.steamid = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for CParental_SetParentalSettings_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 CParental_SetParentalSettings_Response {
    // special fields
    #[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 CParental_SetParentalSettings_Response {
    fn default() -> &'a CParental_SetParentalSettings_Response {
        <CParental_SetParentalSettings_Response as ::protobuf::Message>::default_instance()
    }
}

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

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

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

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

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

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

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

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

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

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

    fn new() -> CParental_SetParentalSettings_Response {
        CParental_SetParentalSettings_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::<CParental_SetParentalSettings_Response>(
                "CParental_SetParentalSettings_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_SetParentalSettings_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 CParental_ValidateToken_Request {
    // message fields
    unlock_token: ::protobuf::SingularField<::std::string::String>,
    // special fields
    #[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 CParental_ValidateToken_Request {
    fn default() -> &'a CParental_ValidateToken_Request {
        <CParental_ValidateToken_Request as ::protobuf::Message>::default_instance()
    }
}

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

    // optional string unlock_token = 1;


    pub fn get_unlock_token(&self) -> &str {
        match self.unlock_token.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_unlock_token(&mut self) {
        self.unlock_token.clear();
    }

    pub fn has_unlock_token(&self) -> bool {
        self.unlock_token.is_some()
    }

    // Param is passed by value, moved
    pub fn set_unlock_token(&mut self, v: ::std::string::String) {
        self.unlock_token = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_unlock_token(&mut self) -> &mut ::std::string::String {
        if self.unlock_token.is_none() {
            self.unlock_token.set_default();
        }
        self.unlock_token.as_mut().unwrap()
    }

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

impl ::protobuf::Message for CParental_ValidateToken_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 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.unlock_token)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.unlock_token.as_ref() {
            my_size += ::protobuf::rt::string_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.unlock_token.as_ref() {
            os.write_string(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() -> CParental_ValidateToken_Request {
        CParental_ValidateToken_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "unlock_token",
                |m: &CParental_ValidateToken_Request| { &m.unlock_token },
                |m: &mut CParental_ValidateToken_Request| { &mut m.unlock_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_ValidateToken_Request>(
                "CParental_ValidateToken_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_ValidateToken_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 CParental_ValidateToken_Response {
    // special fields
    #[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 CParental_ValidateToken_Response {
    fn default() -> &'a CParental_ValidateToken_Response {
        <CParental_ValidateToken_Response as ::protobuf::Message>::default_instance()
    }
}

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

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

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

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

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

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

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

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

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

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

    fn new() -> CParental_ValidateToken_Response {
        CParental_ValidateToken_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::<CParental_ValidateToken_Response>(
                "CParental_ValidateToken_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_ValidateToken_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 CParental_ValidatePassword_Request {
    // message fields
    password: ::protobuf::SingularField<::std::string::String>,
    session: ::protobuf::SingularField<::std::string::String>,
    send_unlock_on_success: ::std::option::Option<bool>,
    // special fields
    #[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 CParental_ValidatePassword_Request {
    fn default() -> &'a CParental_ValidatePassword_Request {
        <CParental_ValidatePassword_Request as ::protobuf::Message>::default_instance()
    }
}

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

    // optional string password = 1;


    pub fn get_password(&self) -> &str {
        match self.password.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_password(&mut self) {
        self.password.clear();
    }

    pub fn has_password(&self) -> bool {
        self.password.is_some()
    }

    // Param is passed by value, moved
    pub fn set_password(&mut self, v: ::std::string::String) {
        self.password = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_password(&mut self) -> &mut ::std::string::String {
        if self.password.is_none() {
            self.password.set_default();
        }
        self.password.as_mut().unwrap()
    }

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

    // optional string session = 2;


    pub fn get_session(&self) -> &str {
        match self.session.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_session(&mut self) {
        self.session.clear();
    }

    pub fn has_session(&self) -> bool {
        self.session.is_some()
    }

    // Param is passed by value, moved
    pub fn set_session(&mut self, v: ::std::string::String) {
        self.session = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_session(&mut self) -> &mut ::std::string::String {
        if self.session.is_none() {
            self.session.set_default();
        }
        self.session.as_mut().unwrap()
    }

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

    // optional bool send_unlock_on_success = 3;


    pub fn get_send_unlock_on_success(&self) -> bool {
        self.send_unlock_on_success.unwrap_or(false)
    }
    pub fn clear_send_unlock_on_success(&mut self) {
        self.send_unlock_on_success = ::std::option::Option::None;
    }

    pub fn has_send_unlock_on_success(&self) -> bool {
        self.send_unlock_on_success.is_some()
    }

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

impl ::protobuf::Message for CParental_ValidatePassword_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 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.password)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.session)?;
                },
                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.send_unlock_on_success = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.password.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.session.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.send_unlock_on_success {
            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(ref v) = self.password.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.session.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.send_unlock_on_success {
            os.write_bool(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() -> CParental_ValidatePassword_Request {
        CParental_ValidatePassword_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "password",
                |m: &CParental_ValidatePassword_Request| { &m.password },
                |m: &mut CParental_ValidatePassword_Request| { &mut m.password },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "session",
                |m: &CParental_ValidatePassword_Request| { &m.session },
                |m: &mut CParental_ValidatePassword_Request| { &mut m.session },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "send_unlock_on_success",
                |m: &CParental_ValidatePassword_Request| { &m.send_unlock_on_success },
                |m: &mut CParental_ValidatePassword_Request| { &mut m.send_unlock_on_success },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_ValidatePassword_Request>(
                "CParental_ValidatePassword_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CParental_ValidatePassword_Request {
    fn clear(&mut self) {
        self.password.clear();
        self.session.clear();
        self.send_unlock_on_success = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for CParental_ValidatePassword_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 CParental_ValidatePassword_Response {
    // message fields
    token: ::protobuf::SingularField<::std::string::String>,
    // special fields
    #[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 CParental_ValidatePassword_Response {
    fn default() -> &'a CParental_ValidatePassword_Response {
        <CParental_ValidatePassword_Response as ::protobuf::Message>::default_instance()
    }
}

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

    // optional string token = 1;


    pub fn get_token(&self) -> &str {
        match self.token.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_token(&mut self) {
        self.token.clear();
    }

    pub fn has_token(&self) -> bool {
        self.token.is_some()
    }

    // Param is passed by value, moved
    pub fn set_token(&mut self, v: ::std::string::String) {
        self.token = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_token(&mut self) -> &mut ::std::string::String {
        if self.token.is_none() {
            self.token.set_default();
        }
        self.token.as_mut().unwrap()
    }

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

impl ::protobuf::Message for CParental_ValidatePassword_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_string_into(wire_type, is, &mut self.token)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.token.as_ref() {
            my_size += ::protobuf::rt::string_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.token.as_ref() {
            os.write_string(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() -> CParental_ValidatePassword_Response {
        CParental_ValidatePassword_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::ProtobufTypeString>(
                "token",
                |m: &CParental_ValidatePassword_Response| { &m.token },
                |m: &mut CParental_ValidatePassword_Response| { &mut m.token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_ValidatePassword_Response>(
                "CParental_ValidatePassword_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_ValidatePassword_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 CParental_LockClient_Request {
    // message fields
    session: ::protobuf::SingularField<::std::string::String>,
    // special fields
    #[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 CParental_LockClient_Request {
    fn default() -> &'a CParental_LockClient_Request {
        <CParental_LockClient_Request as ::protobuf::Message>::default_instance()
    }
}

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

    // optional string session = 1;


    pub fn get_session(&self) -> &str {
        match self.session.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_session(&mut self) {
        self.session.clear();
    }

    pub fn has_session(&self) -> bool {
        self.session.is_some()
    }

    // Param is passed by value, moved
    pub fn set_session(&mut self, v: ::std::string::String) {
        self.session = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_session(&mut self) -> &mut ::std::string::String {
        if self.session.is_none() {
            self.session.set_default();
        }
        self.session.as_mut().unwrap()
    }

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

impl ::protobuf::Message for CParental_LockClient_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 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.session)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.session.as_ref() {
            my_size += ::protobuf::rt::string_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.session.as_ref() {
            os.write_string(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() -> CParental_LockClient_Request {
        CParental_LockClient_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "session",
                |m: &CParental_LockClient_Request| { &m.session },
                |m: &mut CParental_LockClient_Request| { &mut m.session },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_LockClient_Request>(
                "CParental_LockClient_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_LockClient_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 CParental_LockClient_Response {
    // special fields
    #[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 CParental_LockClient_Response {
    fn default() -> &'a CParental_LockClient_Response {
        <CParental_LockClient_Response as ::protobuf::Message>::default_instance()
    }
}

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

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

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

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

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

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

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

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

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

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

    fn new() -> CParental_LockClient_Response {
        CParental_LockClient_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::<CParental_LockClient_Response>(
                "CParental_LockClient_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_LockClient_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 CParental_RequestRecoveryCode_Request {
    // special fields
    #[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 CParental_RequestRecoveryCode_Request {
    fn default() -> &'a CParental_RequestRecoveryCode_Request {
        <CParental_RequestRecoveryCode_Request as ::protobuf::Message>::default_instance()
    }
}

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

impl ::protobuf::Message for CParental_RequestRecoveryCode_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 {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

    fn new() -> CParental_RequestRecoveryCode_Request {
        CParental_RequestRecoveryCode_Request::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::<CParental_RequestRecoveryCode_Request>(
                "CParental_RequestRecoveryCode_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_RequestRecoveryCode_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 CParental_RequestRecoveryCode_Response {
    // special fields
    #[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 CParental_RequestRecoveryCode_Response {
    fn default() -> &'a CParental_RequestRecoveryCode_Response {
        <CParental_RequestRecoveryCode_Response as ::protobuf::Message>::default_instance()
    }
}

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

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

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

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

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

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

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

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

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

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

    fn new() -> CParental_RequestRecoveryCode_Response {
        CParental_RequestRecoveryCode_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::<CParental_RequestRecoveryCode_Response>(
                "CParental_RequestRecoveryCode_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_RequestRecoveryCode_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 CParental_DisableWithRecoveryCode_Request {
    // message fields
    recovery_code: ::std::option::Option<u32>,
    steamid: ::std::option::Option<u64>,
    // special fields
    #[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 CParental_DisableWithRecoveryCode_Request {
    fn default() -> &'a CParental_DisableWithRecoveryCode_Request {
        <CParental_DisableWithRecoveryCode_Request as ::protobuf::Message>::default_instance()
    }
}

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

    // optional uint32 recovery_code = 1;


    pub fn get_recovery_code(&self) -> u32 {
        self.recovery_code.unwrap_or(0)
    }
    pub fn clear_recovery_code(&mut self) {
        self.recovery_code = ::std::option::Option::None;
    }

    pub fn has_recovery_code(&self) -> bool {
        self.recovery_code.is_some()
    }

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

    // optional fixed64 steamid = 10;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

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

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

impl ::protobuf::Message for CParental_DisableWithRecoveryCode_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::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.recovery_code = ::std::option::Option::Some(tmp);
                },
                10 => {
                    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);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.recovery_code {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.steamid {
            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.recovery_code {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_fixed64(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() -> CParental_DisableWithRecoveryCode_Request {
        CParental_DisableWithRecoveryCode_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::ProtobufTypeUint32>(
                "recovery_code",
                |m: &CParental_DisableWithRecoveryCode_Request| { &m.recovery_code },
                |m: &mut CParental_DisableWithRecoveryCode_Request| { &mut m.recovery_code },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "steamid",
                |m: &CParental_DisableWithRecoveryCode_Request| { &m.steamid },
                |m: &mut CParental_DisableWithRecoveryCode_Request| { &mut m.steamid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_DisableWithRecoveryCode_Request>(
                "CParental_DisableWithRecoveryCode_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_DisableWithRecoveryCode_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 CParental_DisableWithRecoveryCode_Response {
    // special fields
    #[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 CParental_DisableWithRecoveryCode_Response {
    fn default() -> &'a CParental_DisableWithRecoveryCode_Response {
        <CParental_DisableWithRecoveryCode_Response as ::protobuf::Message>::default_instance()
    }
}

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

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

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

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

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

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

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

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

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

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

    fn new() -> CParental_DisableWithRecoveryCode_Response {
        CParental_DisableWithRecoveryCode_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::<CParental_DisableWithRecoveryCode_Response>(
                "CParental_DisableWithRecoveryCode_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_DisableWithRecoveryCode_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 CParental_ParentalSettingsChange_Notification {
    // message fields
    serialized_settings: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    signature: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    password: ::protobuf::SingularField<::std::string::String>,
    sessionid: ::protobuf::SingularField<::std::string::String>,
    // special fields
    #[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 CParental_ParentalSettingsChange_Notification {
    fn default() -> &'a CParental_ParentalSettingsChange_Notification {
        <CParental_ParentalSettingsChange_Notification as ::protobuf::Message>::default_instance()
    }
}

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

    // optional bytes serialized_settings = 1;


    pub fn get_serialized_settings(&self) -> &[u8] {
        match self.serialized_settings.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_serialized_settings(&mut self) {
        self.serialized_settings.clear();
    }

    pub fn has_serialized_settings(&self) -> bool {
        self.serialized_settings.is_some()
    }

    // Param is passed by value, moved
    pub fn set_serialized_settings(&mut self, v: ::std::vec::Vec<u8>) {
        self.serialized_settings = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_serialized_settings(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.serialized_settings.is_none() {
            self.serialized_settings.set_default();
        }
        self.serialized_settings.as_mut().unwrap()
    }

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

    // optional bytes signature = 2;


    pub fn get_signature(&self) -> &[u8] {
        match self.signature.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_signature(&mut self) {
        self.signature.clear();
    }

    pub fn has_signature(&self) -> bool {
        self.signature.is_some()
    }

    // Param is passed by value, moved
    pub fn set_signature(&mut self, v: ::std::vec::Vec<u8>) {
        self.signature = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_signature(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.signature.is_none() {
            self.signature.set_default();
        }
        self.signature.as_mut().unwrap()
    }

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

    // optional string password = 3;


    pub fn get_password(&self) -> &str {
        match self.password.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_password(&mut self) {
        self.password.clear();
    }

    pub fn has_password(&self) -> bool {
        self.password.is_some()
    }

    // Param is passed by value, moved
    pub fn set_password(&mut self, v: ::std::string::String) {
        self.password = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_password(&mut self) -> &mut ::std::string::String {
        if self.password.is_none() {
            self.password.set_default();
        }
        self.password.as_mut().unwrap()
    }

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

    // optional string sessionid = 4;


    pub fn get_sessionid(&self) -> &str {
        match self.sessionid.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_sessionid(&mut self) {
        self.sessionid.clear();
    }

    pub fn has_sessionid(&self) -> bool {
        self.sessionid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_sessionid(&mut self, v: ::std::string::String) {
        self.sessionid = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_sessionid(&mut self) -> &mut ::std::string::String {
        if self.sessionid.is_none() {
            self.sessionid.set_default();
        }
        self.sessionid.as_mut().unwrap()
    }

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

impl ::protobuf::Message for CParental_ParentalSettingsChange_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 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.serialized_settings)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.signature)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.password)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.sessionid)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.serialized_settings.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(ref v) = self.signature.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(ref v) = self.password.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(ref v) = self.sessionid.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(ref v) = self.serialized_settings.as_ref() {
            os.write_bytes(1, &v)?;
        }
        if let Some(ref v) = self.signature.as_ref() {
            os.write_bytes(2, &v)?;
        }
        if let Some(ref v) = self.password.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(ref v) = self.sessionid.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() -> CParental_ParentalSettingsChange_Notification {
        CParental_ParentalSettingsChange_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "serialized_settings",
                |m: &CParental_ParentalSettingsChange_Notification| { &m.serialized_settings },
                |m: &mut CParental_ParentalSettingsChange_Notification| { &mut m.serialized_settings },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "signature",
                |m: &CParental_ParentalSettingsChange_Notification| { &m.signature },
                |m: &mut CParental_ParentalSettingsChange_Notification| { &mut m.signature },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "password",
                |m: &CParental_ParentalSettingsChange_Notification| { &m.password },
                |m: &mut CParental_ParentalSettingsChange_Notification| { &mut m.password },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "sessionid",
                |m: &CParental_ParentalSettingsChange_Notification| { &m.sessionid },
                |m: &mut CParental_ParentalSettingsChange_Notification| { &mut m.sessionid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_ParentalSettingsChange_Notification>(
                "CParental_ParentalSettingsChange_Notification",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CParental_ParentalSettingsChange_Notification {
    fn clear(&mut self) {
        self.serialized_settings.clear();
        self.signature.clear();
        self.password.clear();
        self.sessionid.clear();
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for CParental_ParentalSettingsChange_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 CParental_ParentalUnlock_Notification {
    // message fields
    password: ::protobuf::SingularField<::std::string::String>,
    sessionid: ::protobuf::SingularField<::std::string::String>,
    // special fields
    #[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 CParental_ParentalUnlock_Notification {
    fn default() -> &'a CParental_ParentalUnlock_Notification {
        <CParental_ParentalUnlock_Notification as ::protobuf::Message>::default_instance()
    }
}

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

    // optional string password = 1;


    pub fn get_password(&self) -> &str {
        match self.password.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_password(&mut self) {
        self.password.clear();
    }

    pub fn has_password(&self) -> bool {
        self.password.is_some()
    }

    // Param is passed by value, moved
    pub fn set_password(&mut self, v: ::std::string::String) {
        self.password = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_password(&mut self) -> &mut ::std::string::String {
        if self.password.is_none() {
            self.password.set_default();
        }
        self.password.as_mut().unwrap()
    }

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

    // optional string sessionid = 2;


    pub fn get_sessionid(&self) -> &str {
        match self.sessionid.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_sessionid(&mut self) {
        self.sessionid.clear();
    }

    pub fn has_sessionid(&self) -> bool {
        self.sessionid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_sessionid(&mut self, v: ::std::string::String) {
        self.sessionid = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_sessionid(&mut self) -> &mut ::std::string::String {
        if self.sessionid.is_none() {
            self.sessionid.set_default();
        }
        self.sessionid.as_mut().unwrap()
    }

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

impl ::protobuf::Message for CParental_ParentalUnlock_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 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.password)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.sessionid)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.password.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.sessionid.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &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.password.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.sessionid.as_ref() {
            os.write_string(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() -> CParental_ParentalUnlock_Notification {
        CParental_ParentalUnlock_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "password",
                |m: &CParental_ParentalUnlock_Notification| { &m.password },
                |m: &mut CParental_ParentalUnlock_Notification| { &mut m.password },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "sessionid",
                |m: &CParental_ParentalUnlock_Notification| { &m.sessionid },
                |m: &mut CParental_ParentalUnlock_Notification| { &mut m.sessionid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_ParentalUnlock_Notification>(
                "CParental_ParentalUnlock_Notification",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

impl ::protobuf::reflect::ProtobufValue for CParental_ParentalUnlock_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 CParental_ParentalLock_Notification {
    // message fields
    sessionid: ::protobuf::SingularField<::std::string::String>,
    // special fields
    #[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 CParental_ParentalLock_Notification {
    fn default() -> &'a CParental_ParentalLock_Notification {
        <CParental_ParentalLock_Notification as ::protobuf::Message>::default_instance()
    }
}

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

    // optional string sessionid = 1;


    pub fn get_sessionid(&self) -> &str {
        match self.sessionid.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_sessionid(&mut self) {
        self.sessionid.clear();
    }

    pub fn has_sessionid(&self) -> bool {
        self.sessionid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_sessionid(&mut self, v: ::std::string::String) {
        self.sessionid = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_sessionid(&mut self) -> &mut ::std::string::String {
        if self.sessionid.is_none() {
            self.sessionid.set_default();
        }
        self.sessionid.as_mut().unwrap()
    }

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

impl ::protobuf::Message for CParental_ParentalLock_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 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.sessionid)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.sessionid.as_ref() {
            my_size += ::protobuf::rt::string_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.sessionid.as_ref() {
            os.write_string(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() -> CParental_ParentalLock_Notification {
        CParental_ParentalLock_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "sessionid",
                |m: &CParental_ParentalLock_Notification| { &m.sessionid },
                |m: &mut CParental_ParentalLock_Notification| { &mut m.sessionid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_ParentalLock_Notification>(
                "CParental_ParentalLock_Notification",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n(steammessages_parental.steamclient.proto\x1a,steammessages_unified_ba\
    se.steamclient.proto\"B\n\x0bParentalApp\x12\x14\n\x05appid\x18\x01\x20\
    \x01(\rR\x05appid\x12\x1d\n\nis_allowed\x18\x02\x20\x01(\x08R\tisAllowed\
    \"\xfa\x03\n\x10ParentalSettings\x12\x18\n\x07steamid\x18\x01\x20\x01(\
    \x06R\x07steamid\x12&\n\x0fapplist_base_id\x18\x02\x20\x01(\rR\rapplistB\
    aseId\x128\n\x18applist_base_description\x18\x03\x20\x01(\tR\x16applistB\
    aseDescription\x12/\n\x0capplist_base\x18\x04\x20\x03(\x0b2\x0c.Parental\
    AppR\x0bapplistBase\x123\n\x0eapplist_custom\x18\x05\x20\x03(\x0b2\x0c.P\
    arentalAppR\rapplistCustom\x12*\n\x10passwordhashtype\x18\x06\x20\x01(\r\
    R\x10passwordhashtype\x12\x12\n\x04salt\x18\x07\x20\x01(\x0cR\x04salt\
    \x12\"\n\x0cpasswordhash\x18\x08\x20\x01(\x0cR\x0cpasswordhash\x12\x1d\n\
    \nis_enabled\x18\t\x20\x01(\x08R\tisEnabled\x12)\n\x10enabled_features\
    \x18\n\x20\x01(\rR\x0fenabledFeatures\x12%\n\x0erecovery_email\x18\x0b\
    \x20\x01(\tR\rrecoveryEmail\x12/\n\x14is_site_license_lock\x18\x0c\x20\
    \x01(\x08R\x11isSiteLicenseLock\"\xcd\x01\n(CParental_EnableParentalSett\
    ings_Request\x12\x1a\n\x08password\x18\x01\x20\x01(\tR\x08password\x12-\
    \n\x08settings\x18\x02\x20\x01(\x0b2\x11.ParentalSettingsR\x08settings\
    \x12\x1c\n\tsessionid\x18\x03\x20\x01(\tR\tsessionid\x12\x1e\n\nenableco\
    de\x18\x04\x20\x01(\rR\nenablecode\x12\x18\n\x07steamid\x18\n\x20\x01(\
    \x06R\x07steamid\"+\n)CParental_EnableParentalSettings_Response\"a\n)CPa\
    rental_DisableParentalSettings_Request\x12\x1a\n\x08password\x18\x01\x20\
    \x01(\tR\x08password\x12\x18\n\x07steamid\x18\n\x20\x01(\x06R\x07steamid\
    \",\n*CParental_DisableParentalSettings_Response\"A\n%CParental_GetParen\
    talSettings_Request\x12\x18\n\x07steamid\x18\n\x20\x01(\x06R\x07steamid\
    \"W\n&CParental_GetParentalSettings_Response\x12-\n\x08settings\x18\x01\
    \x20\x01(\x0b2\x11.ParentalSettingsR\x08settings\"I\n+CParental_GetSigne\
    dParentalSettings_Request\x12\x1a\n\x08priority\x18\x01\x20\x01(\rR\x08p\
    riority\"}\n,CParental_GetSignedParentalSettings_Response\x12/\n\x13seri\
    alized_settings\x18\x01\x20\x01(\x0cR\x12serializedSettings\x12\x1c\n\ts\
    ignature\x18\x02\x20\x01(\x0cR\tsignature\"\xcd\x01\n%CParental_SetParen\
    talSettings_Request\x12\x1a\n\x08password\x18\x01\x20\x01(\tR\x08passwor\
    d\x12-\n\x08settings\x18\x02\x20\x01(\x0b2\x11.ParentalSettingsR\x08sett\
    ings\x12!\n\x0cnew_password\x18\x03\x20\x01(\tR\x0bnewPassword\x12\x1c\n\
    \tsessionid\x18\x04\x20\x01(\tR\tsessionid\x12\x18\n\x07steamid\x18\n\
    \x20\x01(\x06R\x07steamid\"(\n&CParental_SetParentalSettings_Response\"D\
    \n\x1fCParental_ValidateToken_Request\x12!\n\x0cunlock_token\x18\x01\x20\
    \x01(\tR\x0bunlockToken\"\"\n\x20CParental_ValidateToken_Response\"\x8f\
    \x01\n\"CParental_ValidatePassword_Request\x12\x1a\n\x08password\x18\x01\
    \x20\x01(\tR\x08password\x12\x18\n\x07session\x18\x02\x20\x01(\tR\x07ses\
    sion\x123\n\x16send_unlock_on_success\x18\x03\x20\x01(\x08R\x13sendUnloc\
    kOnSuccess\";\n#CParental_ValidatePassword_Response\x12\x14\n\x05token\
    \x18\x01\x20\x01(\tR\x05token\"8\n\x1cCParental_LockClient_Request\x12\
    \x18\n\x07session\x18\x01\x20\x01(\tR\x07session\"\x1f\n\x1dCParental_Lo\
    ckClient_Response\"'\n%CParental_RequestRecoveryCode_Request\"(\n&CParen\
    tal_RequestRecoveryCode_Response\"j\n)CParental_DisableWithRecoveryCode_\
    Request\x12#\n\rrecovery_code\x18\x01\x20\x01(\rR\x0crecoveryCode\x12\
    \x18\n\x07steamid\x18\n\x20\x01(\x06R\x07steamid\",\n*CParental_DisableW\
    ithRecoveryCode_Response\"\xb8\x01\n-CParental_ParentalSettingsChange_No\
    tification\x12/\n\x13serialized_settings\x18\x01\x20\x01(\x0cR\x12serial\
    izedSettings\x12\x1c\n\tsignature\x18\x02\x20\x01(\x0cR\tsignature\x12\
    \x1a\n\x08password\x18\x03\x20\x01(\tR\x08password\x12\x1c\n\tsessionid\
    \x18\x04\x20\x01(\tR\tsessionid\"a\n%CParental_ParentalUnlock_Notificati\
    on\x12\x1a\n\x08password\x18\x01\x20\x01(\tR\x08password\x12\x1c\n\tsess\
    ionid\x18\x02\x20\x01(\tR\tsessionid\"C\n#CParental_ParentalLock_Notific\
    ation\x12\x1c\n\tsessionid\x18\x01\x20\x01(\tR\tsessionid2\xd2\x0e\n\x08\
    Parental\x12\xd0\x01\n\x16EnableParentalSettings\x12).CParental_EnablePa\
    rentalSettings_Request\x1a*.CParental_EnableParentalSettings_Response\"_\
    \x82\xb5\x18[Enable\x20parental\x20settings\x20for\x20the\x20logged\x20i\
    n\x20account,\x20optionally\x20setting\x20the\x20current\x20settings\x12\
    \xab\x01\n\x17DisableParentalSettings\x12*.CParental_DisableParentalSett\
    ings_Request\x1a+.CParental_DisableParentalSettings_Response\"7\x82\xb5\
    \x183Disable\x20parental\x20settings\x20for\x20the\x20logged\x20in\x20ac\
    count\x12\xa7\x01\n\x13GetParentalSettings\x12&.CParental_GetParentalSet\
    tings_Request\x1a'.CParental_GetParentalSettings_Response\"?\x82\xb5\x18\
    ;Get\x20the\x20current\x20parental\x20settings\x20for\x20the\x20logged\
    \x20in\x20account\x12\xe8\x01\n\x19GetSignedParentalSettings\x12,.CParen\
    tal_GetSignedParentalSettings_Request\x1a-.CParental_GetSignedParentalSe\
    ttings_Response\"n\x82\xb5\x18jGet\x20the\x20current\x20parental\x20sett\
    ings\x20for\x20the\x20logged\x20in\x20account\x20in\x20a\x20form\x20that\
    \x20can\x20by\x20verified\x20by\x20the\x20receiver\x12\xa7\x01\n\x13SetP\
    arentalSettings\x12&.CParental_SetParentalSettings_Request\x1a'.CParenta\
    l_SetParentalSettings_Response\"?\x82\xb5\x18;Set\x20the\x20current\x20p\
    arental\x20settings\x20for\x20the\x20logged\x20in\x20account\x12\xa7\x01\
    \n\rValidateToken\x12\x20.CParental_ValidateToken_Request\x1a!.CParental\
    _ValidateToken_Response\"Q\x82\xb5\x18MCheck\x20if\x20the\x20given\x20pa\
    rental\x20unlock\x20token\x20is\x20correct\x20for\x20the\x20logged\x20in\
    \x20account\x12\xb7\x01\n\x10ValidatePassword\x12#.CParental_ValidatePas\
    sword_Request\x1a$.CParental_ValidatePassword_Response\"X\x82\xb5\x18TVa\
    lidate\x20the\x20plaintext\x20password\x20for\x20the\x20logged\x20in\x20\
    account\x20and\x20return\x20an\x20unlock\x20token\x12\x8f\x01\n\nLockCli\
    ent\x12\x1d.CParental_LockClient_Request\x1a\x1e.CParental_LockClient_Re\
    sponse\"B\x82\xb5\x18>Notify\x20connected\x20clients\x20that\x20a\x20loc\
    k\x20has\x20occurred\x20in\x20a\x20browser\x12\xc3\x01\n\x13RequestRecov\
    eryCode\x12&.CParental_RequestRecoveryCode_Request\x1a'.CParental_Reques\
    tRecoveryCode_Response\"[\x82\xb5\x18WRequest\x20a\x20recovery\x20code\
    \x20be\x20sent\x20to\x20the\x20recovery\x20email\x20address\x20for\x20th\
    e\x20specified\x20account\x12\xaa\x01\n\x17DisableWithRecoveryCode\x12*.\
    CParental_DisableWithRecoveryCode_Request\x1a+.CParental_DisableWithReco\
    veryCode_Response\"6\x82\xb5\x182Attempt\x20a\x20recovery\x20unlock\x20o\
    n\x20the\x20specified\x20account\x1a\x1d\x82\xb5\x18\x19Parental\x20sett\
    ings\x20service2\x86\x04\n\x0eParentalClient\x12\x9c\x01\n\x14NotifySett\
    ingsChange\x12..CParental_ParentalSettingsChange_Notification\x1a\x0b.No\
    Response\"G\x82\xb5\x18CNotification\x20from\x20server\x20to\x20client\
    \x20of\x20a\x20change\x20in\x20parental\x20settings\x12\x94\x01\n\x0cNot\
    ifyUnlock\x12&.CParental_ParentalUnlock_Notification\x1a\x0b.NoResponse\
    \"O\x82\xb5\x18KNotification\x20from\x20server\x20to\x20client\x20that\
    \x20an\x20unlock\x20has\x20occurred\x20in\x20a\x20browser\x12\x8d\x01\n\
    \nNotifyLock\x12$.CParental_ParentalLock_Notification\x1a\x0b.NoResponse\
    \"L\x82\xb5\x18HNotification\x20from\x20server\x20to\x20client\x20that\
    \x20a\x20lock\x20has\x20occurred\x20in\x20a\x20browser\x1a.\x82\xb5\x18&\
    Parental\x20settings\x20client\x20notifications\xc0\xb5\x18\x02B\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()
    })
}