// This file is generated by rust-protobuf 3.5.1. Do not edit
// .proto file is parsed by pure
// @generated

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

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

#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]

//! Generated file from `steammessages_parental.steamclient.proto`
// Generated for lite runtime

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

// @@protoc_insertion_point(message:CParental_EnableParentalSettings_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CParental_EnableParentalSettings_Request {
    // message fields
    // @@protoc_insertion_point(field:CParental_EnableParentalSettings_Request.password)
    pub password: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CParental_EnableParentalSettings_Request.settings)
    pub settings: ::steam_vent_proto_common::protobuf::MessageField<super::steammessages_parental_objects::ParentalSettings>,
    // @@protoc_insertion_point(field:CParental_EnableParentalSettings_Request.sessionid)
    pub sessionid: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CParental_EnableParentalSettings_Request.enablecode)
    pub enablecode: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CParental_EnableParentalSettings_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CParental_EnableParentalSettings_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string password = 1;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_password(&mut self) -> &mut ::std::string::String {
        if self.password.is_none() {
            self.password = ::std::option::Option::Some(::std::string::String::new());
        }
        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 = 3;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_sessionid(&mut self) -> &mut ::std::string::String {
        if self.sessionid.is_none() {
            self.sessionid = ::std::option::Option::Some(::std::string::String::new());
        }
        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 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 steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.password = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.settings)?;
                },
                26 => {
                    self.sessionid = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.enablecode = ::std::option::Option::Some(is.read_uint32()?);
                },
                81 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.password.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.settings.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.sessionid.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.enablecode {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.steamid {
            my_size += 1 + 8;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.password.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.settings.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if let Some(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.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.password = ::std::option::Option::None;
        self.settings.clear();
        self.sessionid = ::std::option::Option::None;
        self.enablecode = ::std::option::Option::None;
        self.steamid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CParental_EnableParentalSettings_Request {
        static instance: CParental_EnableParentalSettings_Request = CParental_EnableParentalSettings_Request {
            password: ::std::option::Option::None,
            settings: ::steam_vent_proto_common::protobuf::MessageField::none(),
            sessionid: ::std::option::Option::None,
            enablecode: ::std::option::Option::None,
            steamid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional string password = 1;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_password(&mut self) -> &mut ::std::string::String {
        if self.password.is_none() {
            self.password = ::std::option::Option::Some(::std::string::String::new());
        }
        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 steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.password = ::std::option::Option::Some(is.read_string()?);
                },
                81 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.password.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_fixed64(10, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional fixed64 steamid = 10;

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

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

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

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.steamid {
            os.write_fixed64(10, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

// @@protoc_insertion_point(message:CParental_GetParentalSettings_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CParental_GetParentalSettings_Response {
    // message fields
    // @@protoc_insertion_point(field:CParental_GetParentalSettings_Response.settings)
    pub settings: ::steam_vent_proto_common::protobuf::MessageField<super::steammessages_parental_objects::ParentalSettings>,
    // special fields
    // @@protoc_insertion_point(special_field:CParental_GetParentalSettings_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.settings)?;
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional uint32 priority = 1;

    pub fn 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 ::steam_vent_proto_common::protobuf::Message for CParental_GetSignedParentalSettings_Request {
    const NAME: &'static str = "CParental_GetSignedParentalSettings_Request";

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.priority = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

impl<'a> ::std::default::Default for &'a CParental_GetSignedParentalSettings_Response {
    fn default() -> &'a CParental_GetSignedParentalSettings_Response {
        <CParental_GetSignedParentalSettings_Response as ::steam_vent_proto_common::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 serialized_settings(&self) -> &[u8] {
        match self.serialized_settings.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_serialized_settings(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.serialized_settings.is_none() {
            self.serialized_settings = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        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 signature(&self) -> &[u8] {
        match self.signature.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_signature(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.signature.is_none() {
            self.signature = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        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 ::steam_vent_proto_common::protobuf::Message for CParental_GetSignedParentalSettings_Response {
    const NAME: &'static str = "CParental_GetSignedParentalSettings_Response";

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.serialized_settings = ::std::option::Option::Some(is.read_bytes()?);
                },
                18 => {
                    self.signature = ::std::option::Option::Some(is.read_bytes()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

// @@protoc_insertion_point(message:CParental_SetParentalSettings_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CParental_SetParentalSettings_Request {
    // message fields
    // @@protoc_insertion_point(field:CParental_SetParentalSettings_Request.password)
    pub password: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CParental_SetParentalSettings_Request.settings)
    pub settings: ::steam_vent_proto_common::protobuf::MessageField<super::steammessages_parental_objects::ParentalSettings>,
    // @@protoc_insertion_point(field:CParental_SetParentalSettings_Request.new_password)
    pub new_password: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CParental_SetParentalSettings_Request.sessionid)
    pub sessionid: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CParental_SetParentalSettings_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CParental_SetParentalSettings_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string password = 1;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_password(&mut self) -> &mut ::std::string::String {
        if self.password.is_none() {
            self.password = ::std::option::Option::Some(::std::string::String::new());
        }
        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 new_password = 3;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_new_password(&mut self) -> &mut ::std::string::String {
        if self.new_password.is_none() {
            self.new_password = ::std::option::Option::Some(::std::string::String::new());
        }
        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 sessionid(&self) -> &str {
        match self.sessionid.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_sessionid(&mut self) -> &mut ::std::string::String {
        if self.sessionid.is_none() {
            self.sessionid = ::std::option::Option::Some(::std::string::String::new());
        }
        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 steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.password = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.settings)?;
                },
                26 => {
                    self.new_password = ::std::option::Option::Some(is.read_string()?);
                },
                34 => {
                    self.sessionid = ::std::option::Option::Some(is.read_string()?);
                },
                81 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.password.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.settings.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.new_password.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.sessionid.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.steamid {
            my_size += 1 + 8;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.password.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.settings.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if let Some(v) = self.new_password.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(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.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.password = ::std::option::Option::None;
        self.settings.clear();
        self.new_password = ::std::option::Option::None;
        self.sessionid = ::std::option::Option::None;
        self.steamid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CParental_SetParentalSettings_Request {
        static instance: CParental_SetParentalSettings_Request = CParental_SetParentalSettings_Request {
            password: ::std::option::Option::None,
            settings: ::steam_vent_proto_common::protobuf::MessageField::none(),
            new_password: ::std::option::Option::None,
            sessionid: ::std::option::Option::None,
            steamid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

impl<'a> ::std::default::Default for &'a CParental_ValidateToken_Request {
    fn default() -> &'a CParental_ValidateToken_Request {
        <CParental_ValidateToken_Request as ::steam_vent_proto_common::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 unlock_token(&self) -> &str {
        match self.unlock_token.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_unlock_token(&mut self) -> &mut ::std::string::String {
        if self.unlock_token.is_none() {
            self.unlock_token = ::std::option::Option::Some(::std::string::String::new());
        }
        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 ::steam_vent_proto_common::protobuf::Message for CParental_ValidateToken_Request {
    const NAME: &'static str = "CParental_ValidateToken_Request";

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.unlock_token = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional string password = 1;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_password(&mut self) -> &mut ::std::string::String {
        if self.password.is_none() {
            self.password = ::std::option::Option::Some(::std::string::String::new());
        }
        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 session(&self) -> &str {
        match self.session.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_session(&mut self) -> &mut ::std::string::String {
        if self.session.is_none() {
            self.session = ::std::option::Option::Some(::std::string::String::new());
        }
        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 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 ::steam_vent_proto_common::protobuf::Message for CParental_ValidatePassword_Request {
    const NAME: &'static str = "CParental_ValidatePassword_Request";

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.password = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.session = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.send_unlock_on_success = ::std::option::Option::Some(is.read_bool()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional string token = 1;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_token(&mut self) -> &mut ::std::string::String {
        if self.token.is_none() {
            self.token = ::std::option::Option::Some(::std::string::String::new());
        }
        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 ::steam_vent_proto_common::protobuf::Message for CParental_ValidatePassword_Response {
    const NAME: &'static str = "CParental_ValidatePassword_Response";

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.token = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional string session = 1;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_session(&mut self) -> &mut ::std::string::String {
        if self.session.is_none() {
            self.session = ::std::option::Option::Some(::std::string::String::new());
        }
        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 ::steam_vent_proto_common::protobuf::Message for CParental_LockClient_Request {
    const NAME: &'static str = "CParental_LockClient_Request";

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.session = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional uint32 features = 1;

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

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

    pub fn has_features(&self) -> bool {
        self.features.is_some()
    }

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

    // optional fixed64 steamid = 10;

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.features = ::std::option::Option::Some(is.read_uint32()?);
                },
                81 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional fixed64 requestid = 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional bool approve = 1;

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

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

    pub fn has_approve(&self) -> bool {
        self.approve.is_some()
    }

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

    // optional fixed64 requestid = 2;

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

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

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

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

    // optional uint32 features = 3;

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

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

    pub fn has_features(&self) -> bool {
        self.features.is_some()
    }

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

    // optional uint32 duration = 4;

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

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

    pub fn has_duration(&self) -> bool {
        self.duration.is_some()
    }

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

    // optional fixed64 steamid = 10;

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.approve = ::std::option::Option::Some(is.read_bool()?);
                },
                17 => {
                    self.requestid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                24 => {
                    self.features = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.duration = ::std::option::Option::Some(is.read_uint32()?);
                },
                81 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.approve {
            my_size += 1 + 1;
        }
        if let Some(v) = self.requestid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.features {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.duration {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.steamid {
            my_size += 1 + 8;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.approve {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.requestid {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.features {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.duration {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_fixed64(10, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.approve = ::std::option::Option::None;
        self.requestid = ::std::option::Option::None;
        self.features = ::std::option::Option::None;
        self.duration = ::std::option::Option::None;
        self.steamid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CParental_ApproveFeatureAccess_Request {
        static instance: CParental_ApproveFeatureAccess_Request = CParental_ApproveFeatureAccess_Request {
            approve: ::std::option::Option::None,
            requestid: ::std::option::Option::None,
            features: ::std::option::Option::None,
            duration: ::std::option::Option::None,
            steamid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional uint32 time_expires = 1;

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

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

    pub fn has_time_expires(&self) -> bool {
        self.time_expires.is_some()
    }

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

    // optional fixed64 steamid = 10;

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.time_expires = ::std::option::Option::Some(is.read_uint32()?);
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.current_playtime_restrictions)?;
                },
                81 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.time_expires {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.current_playtime_restrictions.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if let Some(v) = self.steamid {
            os.write_fixed64(10, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

    fn default_instance() -> &'static CParental_RequestPlaytime_Request {
        static instance: CParental_RequestPlaytime_Request = CParental_RequestPlaytime_Request {
            time_expires: ::std::option::Option::None,
            current_playtime_restrictions: ::steam_vent_proto_common::protobuf::MessageField::none(),
            steamid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional fixed64 requestid = 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// @@protoc_insertion_point(message:CParental_ApprovePlaytime_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CParental_ApprovePlaytime_Request {
    // message fields
    // @@protoc_insertion_point(field:CParental_ApprovePlaytime_Request.approve)
    pub approve: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CParental_ApprovePlaytime_Request.requestid)
    pub requestid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CParental_ApprovePlaytime_Request.restrictions_approved)
    pub restrictions_approved: ::steam_vent_proto_common::protobuf::MessageField<super::steammessages_parental_objects::ParentalTemporaryPlaytimeRestrictions>,
    // @@protoc_insertion_point(field:CParental_ApprovePlaytime_Request.steamid)
    pub steamid: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CParental_ApprovePlaytime_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional bool approve = 1;

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

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

    pub fn has_approve(&self) -> bool {
        self.approve.is_some()
    }

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

    // optional fixed64 requestid = 2;

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

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

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

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

    // optional fixed64 steamid = 10;

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.approve = ::std::option::Option::Some(is.read_bool()?);
                },
                17 => {
                    self.requestid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                26 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.restrictions_approved)?;
                },
                81 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.approve {
            my_size += 1 + 1;
        }
        if let Some(v) = self.requestid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.restrictions_approved.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.steamid {
            my_size += 1 + 8;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.approve {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.requestid {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.restrictions_approved.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        if let Some(v) = self.steamid {
            os.write_fixed64(10, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

    fn default_instance() -> &'static CParental_ApprovePlaytime_Request {
        static instance: CParental_ApprovePlaytime_Request = CParental_ApprovePlaytime_Request {
            approve: ::std::option::Option::None,
            requestid: ::std::option::Option::None,
            restrictions_approved: ::steam_vent_proto_common::protobuf::MessageField::none(),
            steamid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional uint32 rt_include_completed_since = 1;

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

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

    pub fn has_rt_include_completed_since(&self) -> bool {
        self.rt_include_completed_since.is_some()
    }

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

    // optional fixed64 family_groupid = 2;

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

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

    pub fn has_family_groupid(&self) -> bool {
        self.family_groupid.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.rt_include_completed_since = ::std::option::Option::Some(is.read_uint32()?);
                },
                17 => {
                    self.family_groupid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

// @@protoc_insertion_point(message:CParental_GetRequests_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CParental_GetRequests_Response {
    // message fields
    // @@protoc_insertion_point(field:CParental_GetRequests_Response.feature_requests)
    pub feature_requests: ::std::vec::Vec<super::steammessages_parental_objects::ParentalFeatureRequest>,
    // @@protoc_insertion_point(field:CParental_GetRequests_Response.playtime_requests)
    pub playtime_requests: ::std::vec::Vec<super::steammessages_parental_objects::ParentalPlaytimeRequest>,
    // special fields
    // @@protoc_insertion_point(special_field:CParental_GetRequests_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.feature_requests.push(is.read_message()?);
                },
                18 => {
                    self.playtime_requests.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        for v in &self.feature_requests {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        for v in &self.playtime_requests {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

    // optional uint32 day_of_week = 1;

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

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

    pub fn has_day_of_week(&self) -> bool {
        self.day_of_week.is_some()
    }

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

    // optional uint32 minutes_used = 2;

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

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

    pub fn has_minutes_used(&self) -> bool {
        self.minutes_used.is_some()
    }

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

    // optional fixed64 steamid = 10;

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.day_of_week = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.minutes_used = ::std::option::Option::Some(is.read_uint32()?);
                },
                81 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

impl<'a> ::std::default::Default for &'a CParental_ParentalSettingsChange_Notification {
    fn default() -> &'a CParental_ParentalSettingsChange_Notification {
        <CParental_ParentalSettingsChange_Notification as ::steam_vent_proto_common::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 serialized_settings(&self) -> &[u8] {
        match self.serialized_settings.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_serialized_settings(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.serialized_settings.is_none() {
            self.serialized_settings = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        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 signature(&self) -> &[u8] {
        match self.signature.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_signature(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.signature.is_none() {
            self.signature = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        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 password(&self) -> &str {
        match self.password.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_password(&mut self) -> &mut ::std::string::String {
        if self.password.is_none() {
            self.password = ::std::option::Option::Some(::std::string::String::new());
        }
        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 sessionid(&self) -> &str {
        match self.sessionid.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_sessionid(&mut self) -> &mut ::std::string::String {
        if self.sessionid.is_none() {
            self.sessionid = ::std::option::Option::Some(::std::string::String::new());
        }
        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 ::steam_vent_proto_common::protobuf::Message for CParental_ParentalSettingsChange_Notification {
    const NAME: &'static str = "CParental_ParentalSettingsChange_Notification";

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.serialized_settings = ::std::option::Option::Some(is.read_bytes()?);
                },
                18 => {
                    self.signature = ::std::option::Option::Some(is.read_bytes()?);
                },
                26 => {
                    self.password = ::std::option::Option::Some(is.read_string()?);
                },
                34 => {
                    self.sessionid = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.serialized_settings.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(v) = self.signature.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(v) = self.password.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.sessionid.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.serialized_settings.as_ref() {
            os.write_bytes(1, v)?;
        }
        if let Some(v) = self.signature.as_ref() {
            os.write_bytes(2, v)?;
        }
        if let Some(v) = self.password.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.sessionid.as_ref() {
            os.write_string(4, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.serialized_settings = ::std::option::Option::None;
        self.signature = ::std::option::Option::None;
        self.password = ::std::option::Option::None;
        self.sessionid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CParental_ParentalSettingsChange_Notification {
        static instance: CParental_ParentalSettingsChange_Notification = CParental_ParentalSettingsChange_Notification {
            serialized_settings: ::std::option::Option::None,
            signature: ::std::option::Option::None,
            password: ::std::option::Option::None,
            sessionid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional string password = 1;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_password(&mut self) -> &mut ::std::string::String {
        if self.password.is_none() {
            self.password = ::std::option::Option::Some(::std::string::String::new());
        }
        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 sessionid(&self) -> &str {
        match self.sessionid.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_sessionid(&mut self) -> &mut ::std::string::String {
        if self.sessionid.is_none() {
            self.sessionid = ::std::option::Option::Some(::std::string::String::new());
        }
        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 ::steam_vent_proto_common::protobuf::Message for CParental_ParentalUnlock_Notification {
    const NAME: &'static str = "CParental_ParentalUnlock_Notification";

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.password = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.sessionid = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional string sessionid = 1;

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

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

    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 = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_sessionid(&mut self) -> &mut ::std::string::String {
        if self.sessionid.is_none() {
            self.sessionid = ::std::option::Option::Some(::std::string::String::new());
        }
        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 ::steam_vent_proto_common::protobuf::Message for CParental_ParentalLock_Notification {
    const NAME: &'static str = "CParental_ParentalLock_Notification";

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.sessionid = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

    // optional uint32 day_of_week = 1;

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

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

    pub fn has_day_of_week(&self) -> bool {
        self.day_of_week.is_some()
    }

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

    // optional uint32 minutes_used = 2;

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

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

    pub fn has_minutes_used(&self) -> bool {
        self.minutes_used.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.day_of_week = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.minutes_used = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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


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

#[allow(unused_imports)]
use crate::steammessages_base::*;
#[allow(unused_imports)]
use crate::steammessages_unified_base_steamclient::*;
#[allow(unused_imports)]
use crate::steammessages_parental_objects::*;
impl ::steam_vent_proto_common::RpcMessage for CParental_EnableParentalSettings_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CParental_EnableParentalSettings_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CParental_DisableParentalSettings_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CParental_DisableParentalSettings_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_GetParentalSettings_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_GetParentalSettings_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CParental_GetSignedParentalSettings_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CParental_GetSignedParentalSettings_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_SetParentalSettings_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_SetParentalSettings_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_ValidateToken_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_ValidateToken_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_ValidatePassword_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_ValidatePassword_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_LockClient_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_LockClient_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_RequestRecoveryCode_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_RequestRecoveryCode_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_RequestFeatureAccess_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_RequestFeatureAccess_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_ApproveFeatureAccess_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_ApproveFeatureAccess_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_RequestPlaytime_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_RequestPlaytime_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_ApprovePlaytime_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_ApprovePlaytime_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_GetRequests_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_GetRequests_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CParental_ReportPlaytimeAndNotify_Request {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CParental_ReportPlaytimeAndNotify_Response {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage
for CParental_ParentalSettingsChange_Notification {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_ParentalUnlock_Notification {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_ParentalLock_Notification {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for CParental_PlaytimeUsed_Notification {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
///
struct Parental {}
impl ::steam_vent_proto_common::RpcService for Parental {
    const SERVICE_NAME: &'static str = "Parental";
}
///
struct ParentalClient {}
impl ::steam_vent_proto_common::RpcService for ParentalClient {
    const SERVICE_NAME: &'static str = "ParentalClient";
}
impl ::steam_vent_proto_common::RpcMethod for CParental_ApproveFeatureAccess_Request {
    const METHOD_NAME: &'static str = "Parental.ApproveFeatureAccess#1";
    type Response = CParental_ApproveFeatureAccess_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CParental_ApprovePlaytime_Request {
    const METHOD_NAME: &'static str = "Parental.ApprovePlaytime#1";
    type Response = CParental_ApprovePlaytime_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CParental_DisableParentalSettings_Request {
    const METHOD_NAME: &'static str = "Parental.DisableParentalSettings#1";
    type Response = CParental_DisableParentalSettings_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CParental_EnableParentalSettings_Request {
    const METHOD_NAME: &'static str = "Parental.EnableParentalSettings#1";
    type Response = CParental_EnableParentalSettings_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CParental_GetParentalSettings_Request {
    const METHOD_NAME: &'static str = "Parental.GetParentalSettings#1";
    type Response = CParental_GetParentalSettings_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CParental_GetRequests_Request {
    const METHOD_NAME: &'static str = "Parental.GetRequests#1";
    type Response = CParental_GetRequests_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CParental_GetSignedParentalSettings_Request {
    const METHOD_NAME: &'static str = "Parental.GetSignedParentalSettings#1";
    type Response = CParental_GetSignedParentalSettings_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CParental_LockClient_Request {
    const METHOD_NAME: &'static str = "Parental.LockClient#1";
    type Response = CParental_LockClient_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CParental_ParentalLock_Notification {
    const METHOD_NAME: &'static str = "ParentalClient.NotifyLock#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod
for CParental_ParentalSettingsChange_Notification {
    const METHOD_NAME: &'static str = "ParentalClient.NotifySettingsChange#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CParental_ParentalUnlock_Notification {
    const METHOD_NAME: &'static str = "ParentalClient.NotifyUnlock#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CParental_PlaytimeUsed_Notification {
    const METHOD_NAME: &'static str = "ParentalClient.NotifyPlaytimeUsed#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CParental_ReportPlaytimeAndNotify_Request {
    const METHOD_NAME: &'static str = "Parental.ReportPlaytimeAndNotify#1";
    type Response = CParental_ReportPlaytimeAndNotify_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CParental_RequestFeatureAccess_Request {
    const METHOD_NAME: &'static str = "Parental.RequestFeatureAccess#1";
    type Response = CParental_RequestFeatureAccess_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CParental_RequestPlaytime_Request {
    const METHOD_NAME: &'static str = "Parental.RequestPlaytime#1";
    type Response = CParental_RequestPlaytime_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CParental_RequestRecoveryCode_Request {
    const METHOD_NAME: &'static str = "Parental.RequestRecoveryCode#1";
    type Response = CParental_RequestRecoveryCode_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CParental_SetParentalSettings_Request {
    const METHOD_NAME: &'static str = "Parental.SetParentalSettings#1";
    type Response = CParental_SetParentalSettings_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CParental_ValidatePassword_Request {
    const METHOD_NAME: &'static str = "Parental.ValidatePassword#1";
    type Response = CParental_ValidatePassword_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CParental_ValidateToken_Request {
    const METHOD_NAME: &'static str = "Parental.ValidateToken#1";
    type Response = CParental_ValidateToken_Response;
}
