// 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_cloud.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:CCloud_ClientLogUploadCheck_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_ClientLogUploadCheck_Notification {
    // message fields
    // @@protoc_insertion_point(field:CCloud_ClientLogUploadCheck_Notification.client_id)
    pub client_id: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_ClientLogUploadCheck_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint64 client_id = 1;

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

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

    pub fn has_client_id(&self) -> bool {
        self.client_id.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_ClientLogUploadCheck_Notification {
    const NAME: &'static str = "CCloud_ClientLogUploadCheck_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.client_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                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.client_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.client_id {
            os.write_uint64(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() -> CCloud_ClientLogUploadCheck_Notification {
        CCloud_ClientLogUploadCheck_Notification::new()
    }

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

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

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

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

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

    // optional uint64 client_id = 1;

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

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

    pub fn has_client_id(&self) -> bool {
        self.client_id.is_some()
    }

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

    // optional uint64 request_id = 2;

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

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

    pub fn has_request_id(&self) -> bool {
        self.request_id.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_ClientLogUploadComplete_Notification {
    const NAME: &'static str = "CCloud_ClientLogUploadComplete_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.client_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.request_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                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.client_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.request_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.client_id {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.request_id {
            os.write_uint64(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() -> CCloud_ClientLogUploadComplete_Notification {
        CCloud_ClientLogUploadComplete_Notification::new()
    }

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

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

// @@protoc_insertion_point(message:CCloud_BeginHTTPUpload_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_BeginHTTPUpload_Request {
    // message fields
    // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Request.file_size)
    pub file_size: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Request.filename)
    pub filename: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Request.file_sha)
    pub file_sha: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Request.is_public)
    pub is_public: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Request.platforms_to_sync)
    pub platforms_to_sync: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Request.request_headers_names)
    pub request_headers_names: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Request.request_headers_values)
    pub request_headers_values: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Request.upload_batch_id)
    pub upload_batch_id: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_BeginHTTPUpload_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional uint32 file_size = 2;

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

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

    pub fn has_file_size(&self) -> bool {
        self.file_size.is_some()
    }

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

    // optional string filename = 3;

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

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

    pub fn has_filename(&self) -> bool {
        self.filename.is_some()
    }

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

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

    // optional string file_sha = 4;

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

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

    pub fn has_file_sha(&self) -> bool {
        self.file_sha.is_some()
    }

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

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

    // optional bool is_public = 5;

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

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

    pub fn has_is_public(&self) -> bool {
        self.is_public.is_some()
    }

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

    // optional uint64 upload_batch_id = 9;

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

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

    pub fn has_upload_batch_id(&self) -> bool {
        self.upload_batch_id.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_BeginHTTPUpload_Request {
    const NAME: &'static str = "CCloud_BeginHTTPUpload_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.file_size = ::std::option::Option::Some(is.read_uint32()?);
                },
                26 => {
                    self.filename = ::std::option::Option::Some(is.read_string()?);
                },
                34 => {
                    self.file_sha = ::std::option::Option::Some(is.read_string()?);
                },
                40 => {
                    self.is_public = ::std::option::Option::Some(is.read_bool()?);
                },
                50 => {
                    self.platforms_to_sync.push(is.read_string()?);
                },
                58 => {
                    self.request_headers_names.push(is.read_string()?);
                },
                66 => {
                    self.request_headers_values.push(is.read_string()?);
                },
                72 => {
                    self.upload_batch_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.file_size {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.filename.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.file_sha.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.is_public {
            my_size += 1 + 1;
        }
        for value in &self.platforms_to_sync {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &value);
        };
        for value in &self.request_headers_names {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &value);
        };
        for value in &self.request_headers_values {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(8, &value);
        };
        if let Some(v) = self.upload_batch_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(9, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.file_size {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.filename.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.file_sha.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.is_public {
            os.write_bool(5, v)?;
        }
        for v in &self.platforms_to_sync {
            os.write_string(6, &v)?;
        };
        for v in &self.request_headers_names {
            os.write_string(7, &v)?;
        };
        for v in &self.request_headers_values {
            os.write_string(8, &v)?;
        };
        if let Some(v) = self.upload_batch_id {
            os.write_uint64(9, 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() -> CCloud_BeginHTTPUpload_Request {
        CCloud_BeginHTTPUpload_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.file_size = ::std::option::Option::None;
        self.filename = ::std::option::Option::None;
        self.file_sha = ::std::option::Option::None;
        self.is_public = ::std::option::Option::None;
        self.platforms_to_sync.clear();
        self.request_headers_names.clear();
        self.request_headers_values.clear();
        self.upload_batch_id = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_BeginHTTPUpload_Request {
        static instance: CCloud_BeginHTTPUpload_Request = CCloud_BeginHTTPUpload_Request {
            appid: ::std::option::Option::None,
            file_size: ::std::option::Option::None,
            filename: ::std::option::Option::None,
            file_sha: ::std::option::Option::None,
            is_public: ::std::option::Option::None,
            platforms_to_sync: ::std::vec::Vec::new(),
            request_headers_names: ::std::vec::Vec::new(),
            request_headers_values: ::std::vec::Vec::new(),
            upload_batch_id: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CCloud_BeginHTTPUpload_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_BeginHTTPUpload_Response {
    // message fields
    // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Response.ugcid)
    pub ugcid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Response.timestamp)
    pub timestamp: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Response.url_host)
    pub url_host: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Response.url_path)
    pub url_path: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Response.use_https)
    pub use_https: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Response.request_headers)
    pub request_headers: ::std::vec::Vec<ccloud_begin_httpupload_response::HTTPHeaders>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_BeginHTTPUpload_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed64 ugcid = 1;

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

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

    pub fn has_ugcid(&self) -> bool {
        self.ugcid.is_some()
    }

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

    // optional fixed32 timestamp = 2;

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

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

    pub fn has_timestamp(&self) -> bool {
        self.timestamp.is_some()
    }

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

    // optional string url_host = 3;

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

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

    pub fn has_url_host(&self) -> bool {
        self.url_host.is_some()
    }

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

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

    // optional string url_path = 4;

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

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

    pub fn has_url_path(&self) -> bool {
        self.url_path.is_some()
    }

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

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

    // optional bool use_https = 5;

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

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

    pub fn has_use_https(&self) -> bool {
        self.use_https.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_BeginHTTPUpload_Response {
    const NAME: &'static str = "CCloud_BeginHTTPUpload_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.ugcid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                21 => {
                    self.timestamp = ::std::option::Option::Some(is.read_fixed32()?);
                },
                26 => {
                    self.url_host = ::std::option::Option::Some(is.read_string()?);
                },
                34 => {
                    self.url_path = ::std::option::Option::Some(is.read_string()?);
                },
                40 => {
                    self.use_https = ::std::option::Option::Some(is.read_bool()?);
                },
                50 => {
                    self.request_headers.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.ugcid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.timestamp {
            my_size += 1 + 4;
        }
        if let Some(v) = self.url_host.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.url_path.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.use_https {
            my_size += 1 + 1;
        }
        for value in &self.request_headers {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.ugcid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.timestamp {
            os.write_fixed32(2, v)?;
        }
        if let Some(v) = self.url_host.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.url_path.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.use_https {
            os.write_bool(5, v)?;
        }
        for v in &self.request_headers {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, 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() -> CCloud_BeginHTTPUpload_Response {
        CCloud_BeginHTTPUpload_Response::new()
    }

    fn clear(&mut self) {
        self.ugcid = ::std::option::Option::None;
        self.timestamp = ::std::option::Option::None;
        self.url_host = ::std::option::Option::None;
        self.url_path = ::std::option::Option::None;
        self.use_https = ::std::option::Option::None;
        self.request_headers.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_BeginHTTPUpload_Response {
        static instance: CCloud_BeginHTTPUpload_Response = CCloud_BeginHTTPUpload_Response {
            ugcid: ::std::option::Option::None,
            timestamp: ::std::option::Option::None,
            url_host: ::std::option::Option::None,
            url_path: ::std::option::Option::None,
            use_https: ::std::option::Option::None,
            request_headers: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CCloud_BeginHTTPUpload_Response`
pub mod ccloud_begin_httpupload_response {
    // @@protoc_insertion_point(message:CCloud_BeginHTTPUpload_Response.HTTPHeaders)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct HTTPHeaders {
        // message fields
        // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Response.HTTPHeaders.name)
        pub name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CCloud_BeginHTTPUpload_Response.HTTPHeaders.value)
        pub value: ::std::option::Option<::std::string::String>,
        // special fields
        // @@protoc_insertion_point(special_field:CCloud_BeginHTTPUpload_Response.HTTPHeaders.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional string name = 1;

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

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

        pub fn has_name(&self) -> bool {
            self.name.is_some()
        }

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

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

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

        // optional string value = 2;

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

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

        pub fn has_value(&self) -> bool {
            self.value.is_some()
        }

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

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

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

        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.name = ::std::option::Option::Some(is.read_string()?);
                    },
                    18 => {
                        self.value = ::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.name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
            }
            if let Some(v) = self.value.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.name.as_ref() {
                os.write_string(1, v)?;
            }
            if let Some(v) = self.value.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() -> HTTPHeaders {
            HTTPHeaders::new()
        }

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

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

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

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

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

    // optional bool transfer_succeeded = 1;

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

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

    pub fn has_transfer_succeeded(&self) -> bool {
        self.transfer_succeeded.is_some()
    }

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

    // optional uint32 appid = 2;

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

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

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

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

    // optional string file_sha = 3;

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

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

    pub fn has_file_sha(&self) -> bool {
        self.file_sha.is_some()
    }

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

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

    // optional string filename = 4;

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

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

    pub fn has_filename(&self) -> bool {
        self.filename.is_some()
    }

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

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_CommitHTTPUpload_Request {
    const NAME: &'static str = "CCloud_CommitHTTPUpload_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.transfer_succeeded = ::std::option::Option::Some(is.read_bool()?);
                },
                16 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                26 => {
                    self.file_sha = ::std::option::Option::Some(is.read_string()?);
                },
                34 => {
                    self.filename = ::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.transfer_succeeded {
            my_size += 1 + 1;
        }
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.file_sha.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.filename.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.transfer_succeeded {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.file_sha.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.filename.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() -> CCloud_CommitHTTPUpload_Request {
        CCloud_CommitHTTPUpload_Request::new()
    }

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

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

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

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

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

    // optional bool file_committed = 1;

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

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

    pub fn has_file_committed(&self) -> bool {
        self.file_committed.is_some()
    }

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

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

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

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

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

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

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

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional uint32 file_size = 2;

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

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

    pub fn has_file_size(&self) -> bool {
        self.file_size.is_some()
    }

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

    // optional string filename = 3;

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

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

    pub fn has_filename(&self) -> bool {
        self.filename.is_some()
    }

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

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

    // optional string file_sha = 4;

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

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

    pub fn has_file_sha(&self) -> bool {
        self.file_sha.is_some()
    }

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

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

    // optional string content_type = 5;

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

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

    pub fn has_content_type(&self) -> bool {
        self.content_type.is_some()
    }

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

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_BeginUGCUpload_Request {
    const NAME: &'static str = "CCloud_BeginUGCUpload_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.file_size = ::std::option::Option::Some(is.read_uint32()?);
                },
                26 => {
                    self.filename = ::std::option::Option::Some(is.read_string()?);
                },
                34 => {
                    self.file_sha = ::std::option::Option::Some(is.read_string()?);
                },
                42 => {
                    self.content_type = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.file_size {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.filename.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.file_sha.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.content_type.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.file_size {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.filename.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.file_sha.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.content_type.as_ref() {
            os.write_string(5, 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() -> CCloud_BeginUGCUpload_Request {
        CCloud_BeginUGCUpload_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.file_size = ::std::option::Option::None;
        self.filename = ::std::option::Option::None;
        self.file_sha = ::std::option::Option::None;
        self.content_type = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_BeginUGCUpload_Request {
        static instance: CCloud_BeginUGCUpload_Request = CCloud_BeginUGCUpload_Request {
            appid: ::std::option::Option::None,
            file_size: ::std::option::Option::None,
            filename: ::std::option::Option::None,
            file_sha: ::std::option::Option::None,
            content_type: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CCloud_BeginUGCUpload_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_BeginUGCUpload_Response {
    // message fields
    // @@protoc_insertion_point(field:CCloud_BeginUGCUpload_Response.storage_system)
    pub storage_system: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::enums::EPublishedFileStorageSystem>>,
    // @@protoc_insertion_point(field:CCloud_BeginUGCUpload_Response.ugcid)
    pub ugcid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_BeginUGCUpload_Response.timestamp)
    pub timestamp: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_BeginUGCUpload_Response.url_host)
    pub url_host: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_BeginUGCUpload_Response.url_path)
    pub url_path: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_BeginUGCUpload_Response.use_https)
    pub use_https: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_BeginUGCUpload_Response.request_headers)
    pub request_headers: ::std::vec::Vec<ccloud_begin_ugcupload_response::HTTPHeaders>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_BeginUGCUpload_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional .EPublishedFileStorageSystem storage_system = 1;

    pub fn storage_system(&self) -> super::enums::EPublishedFileStorageSystem {
        match self.storage_system {
            Some(e) => e.enum_value_or(super::enums::EPublishedFileStorageSystem::k_EPublishedFileStorageSystemInvalid),
            None => super::enums::EPublishedFileStorageSystem::k_EPublishedFileStorageSystemInvalid,
        }
    }

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

    pub fn has_storage_system(&self) -> bool {
        self.storage_system.is_some()
    }

    // Param is passed by value, moved
    pub fn set_storage_system(&mut self, v: super::enums::EPublishedFileStorageSystem) {
        self.storage_system = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional fixed64 ugcid = 2;

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

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

    pub fn has_ugcid(&self) -> bool {
        self.ugcid.is_some()
    }

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

    // optional fixed32 timestamp = 3;

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

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

    pub fn has_timestamp(&self) -> bool {
        self.timestamp.is_some()
    }

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

    // optional string url_host = 4;

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

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

    pub fn has_url_host(&self) -> bool {
        self.url_host.is_some()
    }

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

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

    // optional string url_path = 5;

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

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

    pub fn has_url_path(&self) -> bool {
        self.url_path.is_some()
    }

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

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

    // optional bool use_https = 6;

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

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

    pub fn has_use_https(&self) -> bool {
        self.use_https.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.storage_system = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                17 => {
                    self.ugcid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                29 => {
                    self.timestamp = ::std::option::Option::Some(is.read_fixed32()?);
                },
                34 => {
                    self.url_host = ::std::option::Option::Some(is.read_string()?);
                },
                42 => {
                    self.url_path = ::std::option::Option::Some(is.read_string()?);
                },
                48 => {
                    self.use_https = ::std::option::Option::Some(is.read_bool()?);
                },
                58 => {
                    self.request_headers.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.storage_system {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v.value());
        }
        if let Some(v) = self.ugcid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.timestamp {
            my_size += 1 + 4;
        }
        if let Some(v) = self.url_host.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.url_path.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &v);
        }
        if let Some(v) = self.use_https {
            my_size += 1 + 1;
        }
        for value in &self.request_headers {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.storage_system {
            os.write_enum(1, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.ugcid {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.timestamp {
            os.write_fixed32(3, v)?;
        }
        if let Some(v) = self.url_host.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.url_path.as_ref() {
            os.write_string(5, v)?;
        }
        if let Some(v) = self.use_https {
            os.write_bool(6, v)?;
        }
        for v in &self.request_headers {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(7, 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() -> CCloud_BeginUGCUpload_Response {
        CCloud_BeginUGCUpload_Response::new()
    }

    fn clear(&mut self) {
        self.storage_system = ::std::option::Option::None;
        self.ugcid = ::std::option::Option::None;
        self.timestamp = ::std::option::Option::None;
        self.url_host = ::std::option::Option::None;
        self.url_path = ::std::option::Option::None;
        self.use_https = ::std::option::Option::None;
        self.request_headers.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_BeginUGCUpload_Response {
        static instance: CCloud_BeginUGCUpload_Response = CCloud_BeginUGCUpload_Response {
            storage_system: ::std::option::Option::None,
            ugcid: ::std::option::Option::None,
            timestamp: ::std::option::Option::None,
            url_host: ::std::option::Option::None,
            url_path: ::std::option::Option::None,
            use_https: ::std::option::Option::None,
            request_headers: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CCloud_BeginUGCUpload_Response`
pub mod ccloud_begin_ugcupload_response {
    // @@protoc_insertion_point(message:CCloud_BeginUGCUpload_Response.HTTPHeaders)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct HTTPHeaders {
        // message fields
        // @@protoc_insertion_point(field:CCloud_BeginUGCUpload_Response.HTTPHeaders.name)
        pub name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CCloud_BeginUGCUpload_Response.HTTPHeaders.value)
        pub value: ::std::option::Option<::std::string::String>,
        // special fields
        // @@protoc_insertion_point(special_field:CCloud_BeginUGCUpload_Response.HTTPHeaders.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional string name = 1;

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

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

        pub fn has_name(&self) -> bool {
            self.name.is_some()
        }

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

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

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

        // optional string value = 2;

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

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

        pub fn has_value(&self) -> bool {
            self.value.is_some()
        }

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

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

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

        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.name = ::std::option::Option::Some(is.read_string()?);
                    },
                    18 => {
                        self.value = ::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.name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
            }
            if let Some(v) = self.value.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.name.as_ref() {
                os.write_string(1, v)?;
            }
            if let Some(v) = self.value.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() -> HTTPHeaders {
            HTTPHeaders::new()
        }

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

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

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

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

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

    // optional bool transfer_succeeded = 1;

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

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

    pub fn has_transfer_succeeded(&self) -> bool {
        self.transfer_succeeded.is_some()
    }

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

    // optional uint32 appid = 2;

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

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

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

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

    // optional fixed64 ugcid = 3;

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

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

    pub fn has_ugcid(&self) -> bool {
        self.ugcid.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_CommitUGCUpload_Request {
    const NAME: &'static str = "CCloud_CommitUGCUpload_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.transfer_succeeded = ::std::option::Option::Some(is.read_bool()?);
                },
                16 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                25 => {
                    self.ugcid = ::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.transfer_succeeded {
            my_size += 1 + 1;
        }
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.ugcid {
            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.transfer_succeeded {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.ugcid {
            os.write_fixed64(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() -> CCloud_CommitUGCUpload_Request {
        CCloud_CommitUGCUpload_Request::new()
    }

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

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

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

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

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

    // optional bool file_committed = 1;

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

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

    pub fn has_file_committed(&self) -> bool {
        self.file_committed.is_some()
    }

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

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

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

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

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

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

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

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

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

    // optional uint64 ugcid = 1;

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

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

    pub fn has_ugcid(&self) -> bool {
        self.ugcid.is_some()
    }

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

    // optional uint32 appid = 2;

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

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_GetFileDetails_Request {
    const NAME: &'static str = "CCloud_GetFileDetails_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.ugcid = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.ugcid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.appid {
            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.ugcid {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.appid {
            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() -> CCloud_GetFileDetails_Request {
        CCloud_GetFileDetails_Request::new()
    }

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

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

// @@protoc_insertion_point(message:CCloud_UserFile)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_UserFile {
    // message fields
    // @@protoc_insertion_point(field:CCloud_UserFile.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_UserFile.ugcid)
    pub ugcid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_UserFile.filename)
    pub filename: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_UserFile.timestamp)
    pub timestamp: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_UserFile.file_size)
    pub file_size: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_UserFile.url)
    pub url: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_UserFile.steamid_creator)
    pub steamid_creator: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_UserFile.flags)
    pub flags: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_UserFile.platforms_to_sync)
    pub platforms_to_sync: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_UserFile.file_sha)
    pub file_sha: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_UserFile.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional uint64 ugcid = 2;

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

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

    pub fn has_ugcid(&self) -> bool {
        self.ugcid.is_some()
    }

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

    // optional string filename = 3;

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

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

    pub fn has_filename(&self) -> bool {
        self.filename.is_some()
    }

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

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

    // optional uint64 timestamp = 4;

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

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

    pub fn has_timestamp(&self) -> bool {
        self.timestamp.is_some()
    }

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

    // optional uint32 file_size = 5;

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

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

    pub fn has_file_size(&self) -> bool {
        self.file_size.is_some()
    }

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

    // optional string url = 6;

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

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

    pub fn has_url(&self) -> bool {
        self.url.is_some()
    }

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

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

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

    // optional fixed64 steamid_creator = 7;

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

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

    pub fn has_steamid_creator(&self) -> bool {
        self.steamid_creator.is_some()
    }

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

    // optional uint32 flags = 8;

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

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

    pub fn has_flags(&self) -> bool {
        self.flags.is_some()
    }

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

    // optional string file_sha = 10;

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

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

    pub fn has_file_sha(&self) -> bool {
        self.file_sha.is_some()
    }

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.ugcid = ::std::option::Option::Some(is.read_uint64()?);
                },
                26 => {
                    self.filename = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.timestamp = ::std::option::Option::Some(is.read_uint64()?);
                },
                40 => {
                    self.file_size = ::std::option::Option::Some(is.read_uint32()?);
                },
                50 => {
                    self.url = ::std::option::Option::Some(is.read_string()?);
                },
                57 => {
                    self.steamid_creator = ::std::option::Option::Some(is.read_fixed64()?);
                },
                64 => {
                    self.flags = ::std::option::Option::Some(is.read_uint32()?);
                },
                74 => {
                    self.platforms_to_sync.push(is.read_string()?);
                },
                82 => {
                    self.file_sha = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.ugcid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.filename.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.timestamp {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(4, v);
        }
        if let Some(v) = self.file_size {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.url.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.steamid_creator {
            my_size += 1 + 8;
        }
        if let Some(v) = self.flags {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, v);
        }
        for value in &self.platforms_to_sync {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &value);
        };
        if let Some(v) = self.file_sha.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(10, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.ugcid {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.filename.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.timestamp {
            os.write_uint64(4, v)?;
        }
        if let Some(v) = self.file_size {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.url.as_ref() {
            os.write_string(6, v)?;
        }
        if let Some(v) = self.steamid_creator {
            os.write_fixed64(7, v)?;
        }
        if let Some(v) = self.flags {
            os.write_uint32(8, v)?;
        }
        for v in &self.platforms_to_sync {
            os.write_string(9, &v)?;
        };
        if let Some(v) = self.file_sha.as_ref() {
            os.write_string(10, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.ugcid = ::std::option::Option::None;
        self.filename = ::std::option::Option::None;
        self.timestamp = ::std::option::Option::None;
        self.file_size = ::std::option::Option::None;
        self.url = ::std::option::Option::None;
        self.steamid_creator = ::std::option::Option::None;
        self.flags = ::std::option::Option::None;
        self.platforms_to_sync.clear();
        self.file_sha = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_UserFile {
        static instance: CCloud_UserFile = CCloud_UserFile {
            appid: ::std::option::Option::None,
            ugcid: ::std::option::Option::None,
            filename: ::std::option::Option::None,
            timestamp: ::std::option::Option::None,
            file_size: ::std::option::Option::None,
            url: ::std::option::Option::None,
            steamid_creator: ::std::option::Option::None,
            flags: ::std::option::Option::None,
            platforms_to_sync: ::std::vec::Vec::new(),
            file_sha: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_GetFileDetails_Response {
    const NAME: &'static str = "CCloud_GetFileDetails_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.details)?;
                },
                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.details.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.details.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() -> CCloud_GetFileDetails_Response {
        CCloud_GetFileDetails_Response::new()
    }

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

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

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

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional bool extended_details = 2;

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

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

    pub fn has_extended_details(&self) -> bool {
        self.extended_details.is_some()
    }

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

    // optional uint32 count = 3;

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

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

    pub fn has_count(&self) -> bool {
        self.count.is_some()
    }

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

    // optional uint32 start_index = 4;

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

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

    pub fn has_start_index(&self) -> bool {
        self.start_index.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_EnumerateUserFiles_Request {
    const NAME: &'static str = "CCloud_EnumerateUserFiles_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.extended_details = ::std::option::Option::Some(is.read_bool()?);
                },
                24 => {
                    self.count = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.start_index = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.extended_details {
            my_size += 1 + 1;
        }
        if let Some(v) = self.count {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.start_index {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.extended_details {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.count {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.start_index {
            os.write_uint32(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() -> CCloud_EnumerateUserFiles_Request {
        CCloud_EnumerateUserFiles_Request::new()
    }

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

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

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

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

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

    // optional uint32 total_files = 2;

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

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

    pub fn has_total_files(&self) -> bool {
        self.total_files.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_EnumerateUserFiles_Response {
    const NAME: &'static str = "CCloud_EnumerateUserFiles_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.files.push(is.read_message()?);
                },
                16 => {
                    self.total_files = ::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;
        for value in &self.files {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.total_files {
            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<()> {
        for v in &self.files {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        if let Some(v) = self.total_files {
            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() -> CCloud_EnumerateUserFiles_Response {
        CCloud_EnumerateUserFiles_Response::new()
    }

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

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

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

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

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

    // optional string filename = 1;

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

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

    pub fn has_filename(&self) -> bool {
        self.filename.is_some()
    }

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

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

    // optional uint32 appid = 2;

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

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

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

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

    // optional uint64 upload_batch_id = 3;

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

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

    pub fn has_upload_batch_id(&self) -> bool {
        self.upload_batch_id.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_Delete_Request {
    const NAME: &'static str = "CCloud_Delete_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.filename = ::std::option::Option::Some(is.read_string()?);
                },
                16 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.upload_batch_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                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.filename.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.upload_batch_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.filename.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.upload_batch_id {
            os.write_uint64(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() -> CCloud_Delete_Request {
        CCloud_Delete_Request::new()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional bytes key = 1;

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

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

    pub fn has_key(&self) -> bool {
        self.key.is_some()
    }

    // Param is passed by value, moved
    pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.key = ::std::option::Option::Some(v);
    }

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

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

    // optional int32 crc = 2;

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

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

    pub fn has_crc(&self) -> bool {
        self.crc.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_GetClientEncryptionKey_Response {
    const NAME: &'static str = "CCloud_GetClientEncryptionKey_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.key = ::std::option::Option::Some(is.read_bytes()?);
                },
                16 => {
                    self.crc = ::std::option::Option::Some(is.read_int32()?);
                },
                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.key.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(v) = self.crc {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_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.key.as_ref() {
            os.write_bytes(1, v)?;
        }
        if let Some(v) = self.crc {
            os.write_int32(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() -> CCloud_GetClientEncryptionKey_Response {
        CCloud_GetClientEncryptionKey_Response::new()
    }

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

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

// @@protoc_insertion_point(message:CCloud_CDNReport_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_CDNReport_Notification {
    // message fields
    // @@protoc_insertion_point(field:CCloud_CDNReport_Notification.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_CDNReport_Notification.url)
    pub url: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_CDNReport_Notification.success)
    pub success: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_CDNReport_Notification.http_status_code)
    pub http_status_code: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_CDNReport_Notification.expected_bytes)
    pub expected_bytes: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_CDNReport_Notification.received_bytes)
    pub received_bytes: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_CDNReport_Notification.duration)
    pub duration: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_CDNReport_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional fixed64 steamid = 1;

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

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

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

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

    // optional string url = 2;

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

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

    pub fn has_url(&self) -> bool {
        self.url.is_some()
    }

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

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

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

    // optional bool success = 3;

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

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

    pub fn has_success(&self) -> bool {
        self.success.is_some()
    }

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

    // optional uint32 http_status_code = 4;

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

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

    pub fn has_http_status_code(&self) -> bool {
        self.http_status_code.is_some()
    }

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

    // optional uint64 expected_bytes = 5;

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

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

    pub fn has_expected_bytes(&self) -> bool {
        self.expected_bytes.is_some()
    }

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

    // optional uint64 received_bytes = 6;

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

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

    pub fn has_received_bytes(&self) -> bool {
        self.received_bytes.is_some()
    }

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

    // optional uint32 duration = 7;

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                9 => {
                    self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
                },
                18 => {
                    self.url = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.success = ::std::option::Option::Some(is.read_bool()?);
                },
                32 => {
                    self.http_status_code = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.expected_bytes = ::std::option::Option::Some(is.read_uint64()?);
                },
                48 => {
                    self.received_bytes = ::std::option::Option::Some(is.read_uint64()?);
                },
                56 => {
                    self.duration = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.steamid {
            my_size += 1 + 8;
        }
        if let Some(v) = self.url.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.success {
            my_size += 1 + 1;
        }
        if let Some(v) = self.http_status_code {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.expected_bytes {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(5, v);
        }
        if let Some(v) = self.received_bytes {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(6, v);
        }
        if let Some(v) = self.duration {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.url.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.success {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.http_status_code {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.expected_bytes {
            os.write_uint64(5, v)?;
        }
        if let Some(v) = self.received_bytes {
            os.write_uint64(6, v)?;
        }
        if let Some(v) = self.duration {
            os.write_uint32(7, 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() -> CCloud_CDNReport_Notification {
        CCloud_CDNReport_Notification::new()
    }

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.url = ::std::option::Option::None;
        self.success = ::std::option::Option::None;
        self.http_status_code = ::std::option::Option::None;
        self.expected_bytes = ::std::option::Option::None;
        self.received_bytes = ::std::option::Option::None;
        self.duration = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_CDNReport_Notification {
        static instance: CCloud_CDNReport_Notification = CCloud_CDNReport_Notification {
            steamid: ::std::option::Option::None,
            url: ::std::option::Option::None,
            success: ::std::option::Option::None,
            http_status_code: ::std::option::Option::None,
            expected_bytes: ::std::option::Option::None,
            received_bytes: ::std::option::Option::None,
            duration: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CCloud_ExternalStorageTransferReport_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_ExternalStorageTransferReport_Notification {
    // message fields
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.host)
    pub host: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.path)
    pub path: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.is_upload)
    pub is_upload: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.success)
    pub success: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.http_status_code)
    pub http_status_code: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.bytes_expected)
    pub bytes_expected: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.bytes_actual)
    pub bytes_actual: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.duration_ms)
    pub duration_ms: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.cellid)
    pub cellid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.proxied)
    pub proxied: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.ipv6_local)
    pub ipv6_local: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.ipv6_remote)
    pub ipv6_remote: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.time_to_connect_ms)
    pub time_to_connect_ms: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.time_to_send_req_ms)
    pub time_to_send_req_ms: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.time_to_first_byte_ms)
    pub time_to_first_byte_ms: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ExternalStorageTransferReport_Notification.time_to_last_byte_ms)
    pub time_to_last_byte_ms: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_ExternalStorageTransferReport_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string host = 1;

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

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

    pub fn has_host(&self) -> bool {
        self.host.is_some()
    }

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

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

    // optional string path = 2;

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

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

    pub fn has_path(&self) -> bool {
        self.path.is_some()
    }

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

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

    // optional bool is_upload = 3;

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

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

    pub fn has_is_upload(&self) -> bool {
        self.is_upload.is_some()
    }

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

    // optional bool success = 4;

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

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

    pub fn has_success(&self) -> bool {
        self.success.is_some()
    }

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

    // optional uint32 http_status_code = 5;

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

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

    pub fn has_http_status_code(&self) -> bool {
        self.http_status_code.is_some()
    }

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

    // optional uint64 bytes_expected = 6;

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

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

    pub fn has_bytes_expected(&self) -> bool {
        self.bytes_expected.is_some()
    }

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

    // optional uint64 bytes_actual = 7;

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

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

    pub fn has_bytes_actual(&self) -> bool {
        self.bytes_actual.is_some()
    }

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

    // optional uint32 duration_ms = 8;

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

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

    pub fn has_duration_ms(&self) -> bool {
        self.duration_ms.is_some()
    }

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

    // optional uint32 cellid = 9;

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

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

    pub fn has_cellid(&self) -> bool {
        self.cellid.is_some()
    }

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

    // optional bool proxied = 10;

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

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

    pub fn has_proxied(&self) -> bool {
        self.proxied.is_some()
    }

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

    // optional bool ipv6_local = 11;

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

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

    pub fn has_ipv6_local(&self) -> bool {
        self.ipv6_local.is_some()
    }

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

    // optional bool ipv6_remote = 12;

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

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

    pub fn has_ipv6_remote(&self) -> bool {
        self.ipv6_remote.is_some()
    }

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

    // optional uint32 time_to_connect_ms = 13;

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

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

    pub fn has_time_to_connect_ms(&self) -> bool {
        self.time_to_connect_ms.is_some()
    }

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

    // optional uint32 time_to_send_req_ms = 14;

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

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

    pub fn has_time_to_send_req_ms(&self) -> bool {
        self.time_to_send_req_ms.is_some()
    }

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

    // optional uint32 time_to_first_byte_ms = 15;

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

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

    pub fn has_time_to_first_byte_ms(&self) -> bool {
        self.time_to_first_byte_ms.is_some()
    }

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

    // optional uint32 time_to_last_byte_ms = 16;

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

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

    pub fn has_time_to_last_byte_ms(&self) -> bool {
        self.time_to_last_byte_ms.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_ExternalStorageTransferReport_Notification {
    const NAME: &'static str = "CCloud_ExternalStorageTransferReport_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.host = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.path = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.is_upload = ::std::option::Option::Some(is.read_bool()?);
                },
                32 => {
                    self.success = ::std::option::Option::Some(is.read_bool()?);
                },
                40 => {
                    self.http_status_code = ::std::option::Option::Some(is.read_uint32()?);
                },
                48 => {
                    self.bytes_expected = ::std::option::Option::Some(is.read_uint64()?);
                },
                56 => {
                    self.bytes_actual = ::std::option::Option::Some(is.read_uint64()?);
                },
                64 => {
                    self.duration_ms = ::std::option::Option::Some(is.read_uint32()?);
                },
                72 => {
                    self.cellid = ::std::option::Option::Some(is.read_uint32()?);
                },
                80 => {
                    self.proxied = ::std::option::Option::Some(is.read_bool()?);
                },
                88 => {
                    self.ipv6_local = ::std::option::Option::Some(is.read_bool()?);
                },
                96 => {
                    self.ipv6_remote = ::std::option::Option::Some(is.read_bool()?);
                },
                104 => {
                    self.time_to_connect_ms = ::std::option::Option::Some(is.read_uint32()?);
                },
                112 => {
                    self.time_to_send_req_ms = ::std::option::Option::Some(is.read_uint32()?);
                },
                120 => {
                    self.time_to_first_byte_ms = ::std::option::Option::Some(is.read_uint32()?);
                },
                128 => {
                    self.time_to_last_byte_ms = ::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.host.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.path.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.is_upload {
            my_size += 1 + 1;
        }
        if let Some(v) = self.success {
            my_size += 1 + 1;
        }
        if let Some(v) = self.http_status_code {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.bytes_expected {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(6, v);
        }
        if let Some(v) = self.bytes_actual {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(7, v);
        }
        if let Some(v) = self.duration_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, v);
        }
        if let Some(v) = self.cellid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
        }
        if let Some(v) = self.proxied {
            my_size += 1 + 1;
        }
        if let Some(v) = self.ipv6_local {
            my_size += 1 + 1;
        }
        if let Some(v) = self.ipv6_remote {
            my_size += 1 + 1;
        }
        if let Some(v) = self.time_to_connect_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(13, v);
        }
        if let Some(v) = self.time_to_send_req_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(14, v);
        }
        if let Some(v) = self.time_to_first_byte_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(15, v);
        }
        if let Some(v) = self.time_to_last_byte_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(16, 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.host.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.path.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.is_upload {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.success {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.http_status_code {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.bytes_expected {
            os.write_uint64(6, v)?;
        }
        if let Some(v) = self.bytes_actual {
            os.write_uint64(7, v)?;
        }
        if let Some(v) = self.duration_ms {
            os.write_uint32(8, v)?;
        }
        if let Some(v) = self.cellid {
            os.write_uint32(9, v)?;
        }
        if let Some(v) = self.proxied {
            os.write_bool(10, v)?;
        }
        if let Some(v) = self.ipv6_local {
            os.write_bool(11, v)?;
        }
        if let Some(v) = self.ipv6_remote {
            os.write_bool(12, v)?;
        }
        if let Some(v) = self.time_to_connect_ms {
            os.write_uint32(13, v)?;
        }
        if let Some(v) = self.time_to_send_req_ms {
            os.write_uint32(14, v)?;
        }
        if let Some(v) = self.time_to_first_byte_ms {
            os.write_uint32(15, v)?;
        }
        if let Some(v) = self.time_to_last_byte_ms {
            os.write_uint32(16, 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() -> CCloud_ExternalStorageTransferReport_Notification {
        CCloud_ExternalStorageTransferReport_Notification::new()
    }

    fn clear(&mut self) {
        self.host = ::std::option::Option::None;
        self.path = ::std::option::Option::None;
        self.is_upload = ::std::option::Option::None;
        self.success = ::std::option::Option::None;
        self.http_status_code = ::std::option::Option::None;
        self.bytes_expected = ::std::option::Option::None;
        self.bytes_actual = ::std::option::Option::None;
        self.duration_ms = ::std::option::Option::None;
        self.cellid = ::std::option::Option::None;
        self.proxied = ::std::option::Option::None;
        self.ipv6_local = ::std::option::Option::None;
        self.ipv6_remote = ::std::option::Option::None;
        self.time_to_connect_ms = ::std::option::Option::None;
        self.time_to_send_req_ms = ::std::option::Option::None;
        self.time_to_first_byte_ms = ::std::option::Option::None;
        self.time_to_last_byte_ms = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_ExternalStorageTransferReport_Notification {
        static instance: CCloud_ExternalStorageTransferReport_Notification = CCloud_ExternalStorageTransferReport_Notification {
            host: ::std::option::Option::None,
            path: ::std::option::Option::None,
            is_upload: ::std::option::Option::None,
            success: ::std::option::Option::None,
            http_status_code: ::std::option::Option::None,
            bytes_expected: ::std::option::Option::None,
            bytes_actual: ::std::option::Option::None,
            duration_ms: ::std::option::Option::None,
            cellid: ::std::option::Option::None,
            proxied: ::std::option::Option::None,
            ipv6_local: ::std::option::Option::None,
            ipv6_remote: ::std::option::Option::None,
            time_to_connect_ms: ::std::option::Option::None,
            time_to_send_req_ms: ::std::option::Option::None,
            time_to_first_byte_ms: ::std::option::Option::None,
            time_to_last_byte_ms: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CCloud_BeginAppUploadBatch_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_BeginAppUploadBatch_Request {
    // message fields
    // @@protoc_insertion_point(field:CCloud_BeginAppUploadBatch_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_BeginAppUploadBatch_Request.machine_name)
    pub machine_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_BeginAppUploadBatch_Request.files_to_upload)
    pub files_to_upload: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_BeginAppUploadBatch_Request.files_to_delete)
    pub files_to_delete: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_BeginAppUploadBatch_Request.client_id)
    pub client_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_BeginAppUploadBatch_Request.app_build_id)
    pub app_build_id: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_BeginAppUploadBatch_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional string machine_name = 2;

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

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

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

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

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

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

    // optional uint64 client_id = 5;

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

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

    pub fn has_client_id(&self) -> bool {
        self.client_id.is_some()
    }

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

    // optional uint64 app_build_id = 6;

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

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

    pub fn has_app_build_id(&self) -> bool {
        self.app_build_id.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_BeginAppUploadBatch_Request {
    const NAME: &'static str = "CCloud_BeginAppUploadBatch_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                18 => {
                    self.machine_name = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    self.files_to_upload.push(is.read_string()?);
                },
                34 => {
                    self.files_to_delete.push(is.read_string()?);
                },
                40 => {
                    self.client_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                48 => {
                    self.app_build_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.machine_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        for value in &self.files_to_upload {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &value);
        };
        for value in &self.files_to_delete {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &value);
        };
        if let Some(v) = self.client_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(5, v);
        }
        if let Some(v) = self.app_build_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(6, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.machine_name.as_ref() {
            os.write_string(2, v)?;
        }
        for v in &self.files_to_upload {
            os.write_string(3, &v)?;
        };
        for v in &self.files_to_delete {
            os.write_string(4, &v)?;
        };
        if let Some(v) = self.client_id {
            os.write_uint64(5, v)?;
        }
        if let Some(v) = self.app_build_id {
            os.write_uint64(6, 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() -> CCloud_BeginAppUploadBatch_Request {
        CCloud_BeginAppUploadBatch_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.machine_name = ::std::option::Option::None;
        self.files_to_upload.clear();
        self.files_to_delete.clear();
        self.client_id = ::std::option::Option::None;
        self.app_build_id = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_BeginAppUploadBatch_Request {
        static instance: CCloud_BeginAppUploadBatch_Request = CCloud_BeginAppUploadBatch_Request {
            appid: ::std::option::Option::None,
            machine_name: ::std::option::Option::None,
            files_to_upload: ::std::vec::Vec::new(),
            files_to_delete: ::std::vec::Vec::new(),
            client_id: ::std::option::Option::None,
            app_build_id: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional uint64 batch_id = 1;

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

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

    pub fn has_batch_id(&self) -> bool {
        self.batch_id.is_some()
    }

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

    // optional uint64 app_change_number = 4;

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

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

    pub fn has_app_change_number(&self) -> bool {
        self.app_change_number.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.batch_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                32 => {
                    self.app_change_number = ::std::option::Option::Some(is.read_uint64()?);
                },
                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.batch_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.app_change_number {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.batch_id {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.app_change_number {
            os.write_uint64(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() -> CCloud_BeginAppUploadBatch_Response {
        CCloud_BeginAppUploadBatch_Response::new()
    }

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

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

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

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional uint64 batch_id = 2;

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

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

    pub fn has_batch_id(&self) -> bool {
        self.batch_id.is_some()
    }

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

    // optional uint32 batch_eresult = 3;

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

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

    pub fn has_batch_eresult(&self) -> bool {
        self.batch_eresult.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional uint64 batch_id = 2;

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

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

    pub fn has_batch_id(&self) -> bool {
        self.batch_id.is_some()
    }

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

    // optional uint32 batch_eresult = 3;

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

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

    pub fn has_batch_eresult(&self) -> bool {
        self.batch_eresult.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_CompleteAppUploadBatch_Request {
    const NAME: &'static str = "CCloud_CompleteAppUploadBatch_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.batch_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.batch_eresult = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

// @@protoc_insertion_point(message:CCloud_ClientBeginFileUpload_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_ClientBeginFileUpload_Request {
    // message fields
    // @@protoc_insertion_point(field:CCloud_ClientBeginFileUpload_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ClientBeginFileUpload_Request.file_size)
    pub file_size: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ClientBeginFileUpload_Request.raw_file_size)
    pub raw_file_size: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ClientBeginFileUpload_Request.file_sha)
    pub file_sha: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CCloud_ClientBeginFileUpload_Request.time_stamp)
    pub time_stamp: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_ClientBeginFileUpload_Request.filename)
    pub filename: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_ClientBeginFileUpload_Request.platforms_to_sync)
    pub platforms_to_sync: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ClientBeginFileUpload_Request.cell_id)
    pub cell_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ClientBeginFileUpload_Request.can_encrypt)
    pub can_encrypt: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_ClientBeginFileUpload_Request.is_shared_file)
    pub is_shared_file: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_ClientBeginFileUpload_Request.deprecated_realm)
    pub deprecated_realm: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ClientBeginFileUpload_Request.upload_batch_id)
    pub upload_batch_id: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_ClientBeginFileUpload_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional uint32 file_size = 2;

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

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

    pub fn has_file_size(&self) -> bool {
        self.file_size.is_some()
    }

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

    // optional uint32 raw_file_size = 3;

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

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

    pub fn has_raw_file_size(&self) -> bool {
        self.raw_file_size.is_some()
    }

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

    // optional bytes file_sha = 4;

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

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

    pub fn has_file_sha(&self) -> bool {
        self.file_sha.is_some()
    }

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

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

    // optional uint64 time_stamp = 5;

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

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

    pub fn has_time_stamp(&self) -> bool {
        self.time_stamp.is_some()
    }

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

    // optional string filename = 6;

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

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

    pub fn has_filename(&self) -> bool {
        self.filename.is_some()
    }

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

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

    // optional uint32 platforms_to_sync = 7;

    pub fn platforms_to_sync(&self) -> u32 {
        self.platforms_to_sync.unwrap_or(4294967295u32)
    }

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

    pub fn has_platforms_to_sync(&self) -> bool {
        self.platforms_to_sync.is_some()
    }

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

    // optional uint32 cell_id = 9;

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

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

    pub fn has_cell_id(&self) -> bool {
        self.cell_id.is_some()
    }

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

    // optional bool can_encrypt = 10;

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

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

    pub fn has_can_encrypt(&self) -> bool {
        self.can_encrypt.is_some()
    }

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

    // optional bool is_shared_file = 11;

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

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

    pub fn has_is_shared_file(&self) -> bool {
        self.is_shared_file.is_some()
    }

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

    // optional uint32 deprecated_realm = 12;

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

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

    pub fn has_deprecated_realm(&self) -> bool {
        self.deprecated_realm.is_some()
    }

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

    // optional uint64 upload_batch_id = 13;

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

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

    pub fn has_upload_batch_id(&self) -> bool {
        self.upload_batch_id.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_ClientBeginFileUpload_Request {
    const NAME: &'static str = "CCloud_ClientBeginFileUpload_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.file_size = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.raw_file_size = ::std::option::Option::Some(is.read_uint32()?);
                },
                34 => {
                    self.file_sha = ::std::option::Option::Some(is.read_bytes()?);
                },
                40 => {
                    self.time_stamp = ::std::option::Option::Some(is.read_uint64()?);
                },
                50 => {
                    self.filename = ::std::option::Option::Some(is.read_string()?);
                },
                56 => {
                    self.platforms_to_sync = ::std::option::Option::Some(is.read_uint32()?);
                },
                72 => {
                    self.cell_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                80 => {
                    self.can_encrypt = ::std::option::Option::Some(is.read_bool()?);
                },
                88 => {
                    self.is_shared_file = ::std::option::Option::Some(is.read_bool()?);
                },
                96 => {
                    self.deprecated_realm = ::std::option::Option::Some(is.read_uint32()?);
                },
                104 => {
                    self.upload_batch_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.file_size {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.raw_file_size {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.file_sha.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(4, &v);
        }
        if let Some(v) = self.time_stamp {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(5, v);
        }
        if let Some(v) = self.filename.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.platforms_to_sync {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.cell_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
        }
        if let Some(v) = self.can_encrypt {
            my_size += 1 + 1;
        }
        if let Some(v) = self.is_shared_file {
            my_size += 1 + 1;
        }
        if let Some(v) = self.deprecated_realm {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(12, v);
        }
        if let Some(v) = self.upload_batch_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(13, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.file_size {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.raw_file_size {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.file_sha.as_ref() {
            os.write_bytes(4, v)?;
        }
        if let Some(v) = self.time_stamp {
            os.write_uint64(5, v)?;
        }
        if let Some(v) = self.filename.as_ref() {
            os.write_string(6, v)?;
        }
        if let Some(v) = self.platforms_to_sync {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.cell_id {
            os.write_uint32(9, v)?;
        }
        if let Some(v) = self.can_encrypt {
            os.write_bool(10, v)?;
        }
        if let Some(v) = self.is_shared_file {
            os.write_bool(11, v)?;
        }
        if let Some(v) = self.deprecated_realm {
            os.write_uint32(12, v)?;
        }
        if let Some(v) = self.upload_batch_id {
            os.write_uint64(13, 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() -> CCloud_ClientBeginFileUpload_Request {
        CCloud_ClientBeginFileUpload_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.file_size = ::std::option::Option::None;
        self.raw_file_size = ::std::option::Option::None;
        self.file_sha = ::std::option::Option::None;
        self.time_stamp = ::std::option::Option::None;
        self.filename = ::std::option::Option::None;
        self.platforms_to_sync = ::std::option::Option::None;
        self.cell_id = ::std::option::Option::None;
        self.can_encrypt = ::std::option::Option::None;
        self.is_shared_file = ::std::option::Option::None;
        self.deprecated_realm = ::std::option::Option::None;
        self.upload_batch_id = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_ClientBeginFileUpload_Request {
        static instance: CCloud_ClientBeginFileUpload_Request = CCloud_ClientBeginFileUpload_Request {
            appid: ::std::option::Option::None,
            file_size: ::std::option::Option::None,
            raw_file_size: ::std::option::Option::None,
            file_sha: ::std::option::Option::None,
            time_stamp: ::std::option::Option::None,
            filename: ::std::option::Option::None,
            platforms_to_sync: ::std::option::Option::None,
            cell_id: ::std::option::Option::None,
            can_encrypt: ::std::option::Option::None,
            is_shared_file: ::std::option::Option::None,
            deprecated_realm: ::std::option::Option::None,
            upload_batch_id: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:ClientCloudFileUploadBlockDetails)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ClientCloudFileUploadBlockDetails {
    // message fields
    // @@protoc_insertion_point(field:ClientCloudFileUploadBlockDetails.url_host)
    pub url_host: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:ClientCloudFileUploadBlockDetails.url_path)
    pub url_path: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:ClientCloudFileUploadBlockDetails.use_https)
    pub use_https: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:ClientCloudFileUploadBlockDetails.http_method)
    pub http_method: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:ClientCloudFileUploadBlockDetails.request_headers)
    pub request_headers: ::std::vec::Vec<client_cloud_file_upload_block_details::HTTPHeaders>,
    // @@protoc_insertion_point(field:ClientCloudFileUploadBlockDetails.block_offset)
    pub block_offset: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:ClientCloudFileUploadBlockDetails.block_length)
    pub block_length: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:ClientCloudFileUploadBlockDetails.explicit_body_data)
    pub explicit_body_data: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:ClientCloudFileUploadBlockDetails.may_parallelize)
    pub may_parallelize: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:ClientCloudFileUploadBlockDetails.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string url_host = 1;

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

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

    pub fn has_url_host(&self) -> bool {
        self.url_host.is_some()
    }

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

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

    // optional string url_path = 2;

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

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

    pub fn has_url_path(&self) -> bool {
        self.url_path.is_some()
    }

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

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

    // optional bool use_https = 3;

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

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

    pub fn has_use_https(&self) -> bool {
        self.use_https.is_some()
    }

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

    // optional int32 http_method = 4;

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

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

    pub fn has_http_method(&self) -> bool {
        self.http_method.is_some()
    }

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

    // optional uint64 block_offset = 6;

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

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

    pub fn has_block_offset(&self) -> bool {
        self.block_offset.is_some()
    }

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

    // optional uint32 block_length = 7;

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

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

    pub fn has_block_length(&self) -> bool {
        self.block_length.is_some()
    }

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

    // optional bytes explicit_body_data = 8;

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

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

    pub fn has_explicit_body_data(&self) -> bool {
        self.explicit_body_data.is_some()
    }

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

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

    // optional bool may_parallelize = 9;

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

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

    pub fn has_may_parallelize(&self) -> bool {
        self.may_parallelize.is_some()
    }

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

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

    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.url_host = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.url_path = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.use_https = ::std::option::Option::Some(is.read_bool()?);
                },
                32 => {
                    self.http_method = ::std::option::Option::Some(is.read_int32()?);
                },
                42 => {
                    self.request_headers.push(is.read_message()?);
                },
                48 => {
                    self.block_offset = ::std::option::Option::Some(is.read_uint64()?);
                },
                56 => {
                    self.block_length = ::std::option::Option::Some(is.read_uint32()?);
                },
                66 => {
                    self.explicit_body_data = ::std::option::Option::Some(is.read_bytes()?);
                },
                72 => {
                    self.may_parallelize = ::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.url_host.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.url_path.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.use_https {
            my_size += 1 + 1;
        }
        if let Some(v) = self.http_method {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v);
        }
        for value in &self.request_headers {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.block_offset {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(6, v);
        }
        if let Some(v) = self.block_length {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.explicit_body_data.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(8, &v);
        }
        if let Some(v) = self.may_parallelize {
            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.url_host.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.url_path.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.use_https {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.http_method {
            os.write_int32(4, v)?;
        }
        for v in &self.request_headers {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        };
        if let Some(v) = self.block_offset {
            os.write_uint64(6, v)?;
        }
        if let Some(v) = self.block_length {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.explicit_body_data.as_ref() {
            os.write_bytes(8, v)?;
        }
        if let Some(v) = self.may_parallelize {
            os.write_bool(9, 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() -> ClientCloudFileUploadBlockDetails {
        ClientCloudFileUploadBlockDetails::new()
    }

    fn clear(&mut self) {
        self.url_host = ::std::option::Option::None;
        self.url_path = ::std::option::Option::None;
        self.use_https = ::std::option::Option::None;
        self.http_method = ::std::option::Option::None;
        self.request_headers.clear();
        self.block_offset = ::std::option::Option::None;
        self.block_length = ::std::option::Option::None;
        self.explicit_body_data = ::std::option::Option::None;
        self.may_parallelize = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ClientCloudFileUploadBlockDetails {
        static instance: ClientCloudFileUploadBlockDetails = ClientCloudFileUploadBlockDetails {
            url_host: ::std::option::Option::None,
            url_path: ::std::option::Option::None,
            use_https: ::std::option::Option::None,
            http_method: ::std::option::Option::None,
            request_headers: ::std::vec::Vec::new(),
            block_offset: ::std::option::Option::None,
            block_length: ::std::option::Option::None,
            explicit_body_data: ::std::option::Option::None,
            may_parallelize: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `ClientCloudFileUploadBlockDetails`
pub mod client_cloud_file_upload_block_details {
    // @@protoc_insertion_point(message:ClientCloudFileUploadBlockDetails.HTTPHeaders)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct HTTPHeaders {
        // message fields
        // @@protoc_insertion_point(field:ClientCloudFileUploadBlockDetails.HTTPHeaders.name)
        pub name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:ClientCloudFileUploadBlockDetails.HTTPHeaders.value)
        pub value: ::std::option::Option<::std::string::String>,
        // special fields
        // @@protoc_insertion_point(special_field:ClientCloudFileUploadBlockDetails.HTTPHeaders.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional string name = 1;

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

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

        pub fn has_name(&self) -> bool {
            self.name.is_some()
        }

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

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

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

        // optional string value = 2;

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

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

        pub fn has_value(&self) -> bool {
            self.value.is_some()
        }

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

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

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

        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.name = ::std::option::Option::Some(is.read_string()?);
                    },
                    18 => {
                        self.value = ::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.name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
            }
            if let Some(v) = self.value.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.name.as_ref() {
                os.write_string(1, v)?;
            }
            if let Some(v) = self.value.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() -> HTTPHeaders {
            HTTPHeaders::new()
        }

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

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

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

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

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

    // optional bool encrypt_file = 1;

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

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

    pub fn has_encrypt_file(&self) -> bool {
        self.encrypt_file.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.encrypt_file = ::std::option::Option::Some(is.read_bool()?);
                },
                18 => {
                    self.block_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;
        if let Some(v) = self.encrypt_file {
            my_size += 1 + 1;
        }
        for value in &self.block_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<()> {
        if let Some(v) = self.encrypt_file {
            os.write_bool(1, v)?;
        }
        for v in &self.block_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() -> CCloud_ClientBeginFileUpload_Response {
        CCloud_ClientBeginFileUpload_Response::new()
    }

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

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

// @@protoc_insertion_point(message:CCloud_ClientCommitFileUpload_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_ClientCommitFileUpload_Request {
    // message fields
    // @@protoc_insertion_point(field:CCloud_ClientCommitFileUpload_Request.transfer_succeeded)
    pub transfer_succeeded: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_ClientCommitFileUpload_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ClientCommitFileUpload_Request.file_sha)
    pub file_sha: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CCloud_ClientCommitFileUpload_Request.filename)
    pub filename: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_ClientCommitFileUpload_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional bool transfer_succeeded = 1;

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

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

    pub fn has_transfer_succeeded(&self) -> bool {
        self.transfer_succeeded.is_some()
    }

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

    // optional uint32 appid = 2;

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

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

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

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

    // optional bytes file_sha = 3;

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

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

    pub fn has_file_sha(&self) -> bool {
        self.file_sha.is_some()
    }

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

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

    // optional string filename = 4;

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

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

    pub fn has_filename(&self) -> bool {
        self.filename.is_some()
    }

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

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_ClientCommitFileUpload_Request {
    const NAME: &'static str = "CCloud_ClientCommitFileUpload_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.transfer_succeeded = ::std::option::Option::Some(is.read_bool()?);
                },
                16 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                26 => {
                    self.file_sha = ::std::option::Option::Some(is.read_bytes()?);
                },
                34 => {
                    self.filename = ::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.transfer_succeeded {
            my_size += 1 + 1;
        }
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.file_sha.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(3, &v);
        }
        if let Some(v) = self.filename.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.transfer_succeeded {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.appid {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.file_sha.as_ref() {
            os.write_bytes(3, v)?;
        }
        if let Some(v) = self.filename.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() -> CCloud_ClientCommitFileUpload_Request {
        CCloud_ClientCommitFileUpload_Request::new()
    }

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

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

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

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

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

    // optional bool file_committed = 1;

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

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

    pub fn has_file_committed(&self) -> bool {
        self.file_committed.is_some()
    }

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

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

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

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

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

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

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

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional string filename = 2;

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

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

    pub fn has_filename(&self) -> bool {
        self.filename.is_some()
    }

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

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

    // optional uint32 realm = 3;

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

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

    pub fn has_realm(&self) -> bool {
        self.realm.is_some()
    }

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

    // optional bool force_proxy = 4;

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

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

    pub fn has_force_proxy(&self) -> bool {
        self.force_proxy.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_ClientFileDownload_Request {
    const NAME: &'static str = "CCloud_ClientFileDownload_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                18 => {
                    self.filename = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.realm = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.force_proxy = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.filename.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.realm {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.force_proxy {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.filename.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.realm {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.force_proxy {
            os.write_bool(4, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

// @@protoc_insertion_point(message:CCloud_ClientFileDownload_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_ClientFileDownload_Response {
    // message fields
    // @@protoc_insertion_point(field:CCloud_ClientFileDownload_Response.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ClientFileDownload_Response.file_size)
    pub file_size: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ClientFileDownload_Response.raw_file_size)
    pub raw_file_size: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ClientFileDownload_Response.sha_file)
    pub sha_file: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CCloud_ClientFileDownload_Response.time_stamp)
    pub time_stamp: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_ClientFileDownload_Response.is_explicit_delete)
    pub is_explicit_delete: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_ClientFileDownload_Response.url_host)
    pub url_host: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_ClientFileDownload_Response.url_path)
    pub url_path: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_ClientFileDownload_Response.use_https)
    pub use_https: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_ClientFileDownload_Response.request_headers)
    pub request_headers: ::std::vec::Vec<ccloud_client_file_download_response::HTTPHeaders>,
    // @@protoc_insertion_point(field:CCloud_ClientFileDownload_Response.encrypted)
    pub encrypted: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_ClientFileDownload_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional uint32 file_size = 2;

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

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

    pub fn has_file_size(&self) -> bool {
        self.file_size.is_some()
    }

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

    // optional uint32 raw_file_size = 3;

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

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

    pub fn has_raw_file_size(&self) -> bool {
        self.raw_file_size.is_some()
    }

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

    // optional bytes sha_file = 4;

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

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

    pub fn has_sha_file(&self) -> bool {
        self.sha_file.is_some()
    }

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

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

    // optional uint64 time_stamp = 5;

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

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

    pub fn has_time_stamp(&self) -> bool {
        self.time_stamp.is_some()
    }

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

    // optional bool is_explicit_delete = 6;

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

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

    pub fn has_is_explicit_delete(&self) -> bool {
        self.is_explicit_delete.is_some()
    }

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

    // optional string url_host = 7;

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

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

    pub fn has_url_host(&self) -> bool {
        self.url_host.is_some()
    }

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

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

    // optional string url_path = 8;

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

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

    pub fn has_url_path(&self) -> bool {
        self.url_path.is_some()
    }

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

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

    // optional bool use_https = 9;

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

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

    pub fn has_use_https(&self) -> bool {
        self.use_https.is_some()
    }

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

    // optional bool encrypted = 11;

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

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

    pub fn has_encrypted(&self) -> bool {
        self.encrypted.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.file_size = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.raw_file_size = ::std::option::Option::Some(is.read_uint32()?);
                },
                34 => {
                    self.sha_file = ::std::option::Option::Some(is.read_bytes()?);
                },
                40 => {
                    self.time_stamp = ::std::option::Option::Some(is.read_uint64()?);
                },
                48 => {
                    self.is_explicit_delete = ::std::option::Option::Some(is.read_bool()?);
                },
                58 => {
                    self.url_host = ::std::option::Option::Some(is.read_string()?);
                },
                66 => {
                    self.url_path = ::std::option::Option::Some(is.read_string()?);
                },
                72 => {
                    self.use_https = ::std::option::Option::Some(is.read_bool()?);
                },
                82 => {
                    self.request_headers.push(is.read_message()?);
                },
                88 => {
                    self.encrypted = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.file_size {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.raw_file_size {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.sha_file.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(4, &v);
        }
        if let Some(v) = self.time_stamp {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(5, v);
        }
        if let Some(v) = self.is_explicit_delete {
            my_size += 1 + 1;
        }
        if let Some(v) = self.url_host.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
        }
        if let Some(v) = self.url_path.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(8, &v);
        }
        if let Some(v) = self.use_https {
            my_size += 1 + 1;
        }
        for value in &self.request_headers {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.encrypted {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.file_size {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.raw_file_size {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.sha_file.as_ref() {
            os.write_bytes(4, v)?;
        }
        if let Some(v) = self.time_stamp {
            os.write_uint64(5, v)?;
        }
        if let Some(v) = self.is_explicit_delete {
            os.write_bool(6, v)?;
        }
        if let Some(v) = self.url_host.as_ref() {
            os.write_string(7, v)?;
        }
        if let Some(v) = self.url_path.as_ref() {
            os.write_string(8, v)?;
        }
        if let Some(v) = self.use_https {
            os.write_bool(9, v)?;
        }
        for v in &self.request_headers {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
        };
        if let Some(v) = self.encrypted {
            os.write_bool(11, 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() -> CCloud_ClientFileDownload_Response {
        CCloud_ClientFileDownload_Response::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.file_size = ::std::option::Option::None;
        self.raw_file_size = ::std::option::Option::None;
        self.sha_file = ::std::option::Option::None;
        self.time_stamp = ::std::option::Option::None;
        self.is_explicit_delete = ::std::option::Option::None;
        self.url_host = ::std::option::Option::None;
        self.url_path = ::std::option::Option::None;
        self.use_https = ::std::option::Option::None;
        self.request_headers.clear();
        self.encrypted = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_ClientFileDownload_Response {
        static instance: CCloud_ClientFileDownload_Response = CCloud_ClientFileDownload_Response {
            appid: ::std::option::Option::None,
            file_size: ::std::option::Option::None,
            raw_file_size: ::std::option::Option::None,
            sha_file: ::std::option::Option::None,
            time_stamp: ::std::option::Option::None,
            is_explicit_delete: ::std::option::Option::None,
            url_host: ::std::option::Option::None,
            url_path: ::std::option::Option::None,
            use_https: ::std::option::Option::None,
            request_headers: ::std::vec::Vec::new(),
            encrypted: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CCloud_ClientFileDownload_Response`
pub mod ccloud_client_file_download_response {
    // @@protoc_insertion_point(message:CCloud_ClientFileDownload_Response.HTTPHeaders)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct HTTPHeaders {
        // message fields
        // @@protoc_insertion_point(field:CCloud_ClientFileDownload_Response.HTTPHeaders.name)
        pub name: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CCloud_ClientFileDownload_Response.HTTPHeaders.value)
        pub value: ::std::option::Option<::std::string::String>,
        // special fields
        // @@protoc_insertion_point(special_field:CCloud_ClientFileDownload_Response.HTTPHeaders.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional string name = 1;

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

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

        pub fn has_name(&self) -> bool {
            self.name.is_some()
        }

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

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

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

        // optional string value = 2;

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

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

        pub fn has_value(&self) -> bool {
            self.value.is_some()
        }

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

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

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

        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.name = ::std::option::Option::Some(is.read_string()?);
                    },
                    18 => {
                        self.value = ::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.name.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
            }
            if let Some(v) = self.value.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.name.as_ref() {
                os.write_string(1, v)?;
            }
            if let Some(v) = self.value.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() -> HTTPHeaders {
            HTTPHeaders::new()
        }

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

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

// @@protoc_insertion_point(message:CCloud_ClientDeleteFile_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_ClientDeleteFile_Request {
    // message fields
    // @@protoc_insertion_point(field:CCloud_ClientDeleteFile_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ClientDeleteFile_Request.filename)
    pub filename: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_ClientDeleteFile_Request.is_explicit_delete)
    pub is_explicit_delete: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_ClientDeleteFile_Request.upload_batch_id)
    pub upload_batch_id: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_ClientDeleteFile_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional string filename = 2;

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

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

    pub fn has_filename(&self) -> bool {
        self.filename.is_some()
    }

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

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

    // optional bool is_explicit_delete = 3;

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

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

    pub fn has_is_explicit_delete(&self) -> bool {
        self.is_explicit_delete.is_some()
    }

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

    // optional uint64 upload_batch_id = 4;

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

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

    pub fn has_upload_batch_id(&self) -> bool {
        self.upload_batch_id.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_ClientDeleteFile_Request {
    const NAME: &'static str = "CCloud_ClientDeleteFile_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                18 => {
                    self.filename = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.is_explicit_delete = ::std::option::Option::Some(is.read_bool()?);
                },
                32 => {
                    self.upload_batch_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.filename.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.is_explicit_delete {
            my_size += 1 + 1;
        }
        if let Some(v) = self.upload_batch_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.filename.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.is_explicit_delete {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.upload_batch_id {
            os.write_uint64(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() -> CCloud_ClientDeleteFile_Request {
        CCloud_ClientDeleteFile_Request::new()
    }

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

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

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

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

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

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

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

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

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

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional bool chose_local_files = 2;

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

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

    pub fn has_chose_local_files(&self) -> bool {
        self.chose_local_files.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.chose_local_files = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.chose_local_files {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.chose_local_files {
            os.write_bool(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() -> CCloud_ClientConflictResolution_Notification {
        CCloud_ClientConflictResolution_Notification::new()
    }

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

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

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

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional uint64 synced_change_number = 2;

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

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

    pub fn has_synced_change_number(&self) -> bool {
        self.synced_change_number.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_GetAppFileChangelist_Request {
    const NAME: &'static str = "CCloud_GetAppFileChangelist_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.synced_change_number = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.synced_change_number {
            os.write_uint64(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() -> CCloud_GetAppFileChangelist_Request {
        CCloud_GetAppFileChangelist_Request::new()
    }

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

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

// @@protoc_insertion_point(message:CCloud_AppFileInfo)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_AppFileInfo {
    // message fields
    // @@protoc_insertion_point(field:CCloud_AppFileInfo.file_name)
    pub file_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_AppFileInfo.sha_file)
    pub sha_file: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:CCloud_AppFileInfo.time_stamp)
    pub time_stamp: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_AppFileInfo.raw_file_size)
    pub raw_file_size: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_AppFileInfo.persist_state)
    pub persist_state: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::enums::ECloudStoragePersistState>>,
    // @@protoc_insertion_point(field:CCloud_AppFileInfo.platforms_to_sync)
    pub platforms_to_sync: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_AppFileInfo.path_prefix_index)
    pub path_prefix_index: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_AppFileInfo.machine_name_index)
    pub machine_name_index: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_AppFileInfo.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string file_name = 1;

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

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

    pub fn has_file_name(&self) -> bool {
        self.file_name.is_some()
    }

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

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

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

    // optional bytes sha_file = 2;

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

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

    pub fn has_sha_file(&self) -> bool {
        self.sha_file.is_some()
    }

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

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

    // optional uint64 time_stamp = 3;

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

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

    pub fn has_time_stamp(&self) -> bool {
        self.time_stamp.is_some()
    }

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

    // optional uint32 raw_file_size = 4;

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

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

    pub fn has_raw_file_size(&self) -> bool {
        self.raw_file_size.is_some()
    }

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

    // optional .ECloudStoragePersistState persist_state = 5;

    pub fn persist_state(&self) -> super::enums::ECloudStoragePersistState {
        match self.persist_state {
            Some(e) => e.enum_value_or(super::enums::ECloudStoragePersistState::k_ECloudStoragePersistStatePersisted),
            None => super::enums::ECloudStoragePersistState::k_ECloudStoragePersistStatePersisted,
        }
    }

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

    pub fn has_persist_state(&self) -> bool {
        self.persist_state.is_some()
    }

    // Param is passed by value, moved
    pub fn set_persist_state(&mut self, v: super::enums::ECloudStoragePersistState) {
        self.persist_state = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }

    // optional uint32 platforms_to_sync = 6;

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

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

    pub fn has_platforms_to_sync(&self) -> bool {
        self.platforms_to_sync.is_some()
    }

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

    // optional uint32 path_prefix_index = 7;

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

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

    pub fn has_path_prefix_index(&self) -> bool {
        self.path_prefix_index.is_some()
    }

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

    // optional uint32 machine_name_index = 8;

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

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

    pub fn has_machine_name_index(&self) -> bool {
        self.machine_name_index.is_some()
    }

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

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

    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.file_name = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.sha_file = ::std::option::Option::Some(is.read_bytes()?);
                },
                24 => {
                    self.time_stamp = ::std::option::Option::Some(is.read_uint64()?);
                },
                32 => {
                    self.raw_file_size = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.persist_state = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                48 => {
                    self.platforms_to_sync = ::std::option::Option::Some(is.read_uint32()?);
                },
                56 => {
                    self.path_prefix_index = ::std::option::Option::Some(is.read_uint32()?);
                },
                64 => {
                    self.machine_name_index = ::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.file_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.sha_file.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(v) = self.time_stamp {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
        }
        if let Some(v) = self.raw_file_size {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.persist_state {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v.value());
        }
        if let Some(v) = self.platforms_to_sync {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.path_prefix_index {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.machine_name_index {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, 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.file_name.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.sha_file.as_ref() {
            os.write_bytes(2, v)?;
        }
        if let Some(v) = self.time_stamp {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.raw_file_size {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.persist_state {
            os.write_enum(5, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.platforms_to_sync {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.path_prefix_index {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.machine_name_index {
            os.write_uint32(8, 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() -> CCloud_AppFileInfo {
        CCloud_AppFileInfo::new()
    }

    fn clear(&mut self) {
        self.file_name = ::std::option::Option::None;
        self.sha_file = ::std::option::Option::None;
        self.time_stamp = ::std::option::Option::None;
        self.raw_file_size = ::std::option::Option::None;
        self.persist_state = ::std::option::Option::None;
        self.platforms_to_sync = ::std::option::Option::None;
        self.path_prefix_index = ::std::option::Option::None;
        self.machine_name_index = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_AppFileInfo {
        static instance: CCloud_AppFileInfo = CCloud_AppFileInfo {
            file_name: ::std::option::Option::None,
            sha_file: ::std::option::Option::None,
            time_stamp: ::std::option::Option::None,
            raw_file_size: ::std::option::Option::None,
            persist_state: ::std::option::Option::None,
            platforms_to_sync: ::std::option::Option::None,
            path_prefix_index: ::std::option::Option::None,
            machine_name_index: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CCloud_GetAppFileChangelist_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_GetAppFileChangelist_Response {
    // message fields
    // @@protoc_insertion_point(field:CCloud_GetAppFileChangelist_Response.current_change_number)
    pub current_change_number: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_GetAppFileChangelist_Response.files)
    pub files: ::std::vec::Vec<CCloud_AppFileInfo>,
    // @@protoc_insertion_point(field:CCloud_GetAppFileChangelist_Response.is_only_delta)
    pub is_only_delta: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_GetAppFileChangelist_Response.path_prefixes)
    pub path_prefixes: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_GetAppFileChangelist_Response.machine_names)
    pub machine_names: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_GetAppFileChangelist_Response.app_buildid_hwm)
    pub app_buildid_hwm: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_GetAppFileChangelist_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint64 current_change_number = 1;

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

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

    pub fn has_current_change_number(&self) -> bool {
        self.current_change_number.is_some()
    }

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

    // optional bool is_only_delta = 3;

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

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

    pub fn has_is_only_delta(&self) -> bool {
        self.is_only_delta.is_some()
    }

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

    // optional uint64 app_buildid_hwm = 6;

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

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

    pub fn has_app_buildid_hwm(&self) -> bool {
        self.app_buildid_hwm.is_some()
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.current_change_number = ::std::option::Option::Some(is.read_uint64()?);
                },
                18 => {
                    self.files.push(is.read_message()?);
                },
                24 => {
                    self.is_only_delta = ::std::option::Option::Some(is.read_bool()?);
                },
                34 => {
                    self.path_prefixes.push(is.read_string()?);
                },
                42 => {
                    self.machine_names.push(is.read_string()?);
                },
                48 => {
                    self.app_buildid_hwm = ::std::option::Option::Some(is.read_uint64()?);
                },
                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.current_change_number {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        for value in &self.files {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.is_only_delta {
            my_size += 1 + 1;
        }
        for value in &self.path_prefixes {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &value);
        };
        for value in &self.machine_names {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &value);
        };
        if let Some(v) = self.app_buildid_hwm {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(6, 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.current_change_number {
            os.write_uint64(1, v)?;
        }
        for v in &self.files {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        if let Some(v) = self.is_only_delta {
            os.write_bool(3, v)?;
        }
        for v in &self.path_prefixes {
            os.write_string(4, &v)?;
        };
        for v in &self.machine_names {
            os.write_string(5, &v)?;
        };
        if let Some(v) = self.app_buildid_hwm {
            os.write_uint64(6, 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() -> CCloud_GetAppFileChangelist_Response {
        CCloud_GetAppFileChangelist_Response::new()
    }

    fn clear(&mut self) {
        self.current_change_number = ::std::option::Option::None;
        self.files.clear();
        self.is_only_delta = ::std::option::Option::None;
        self.path_prefixes.clear();
        self.machine_names.clear();
        self.app_buildid_hwm = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_GetAppFileChangelist_Response {
        static instance: CCloud_GetAppFileChangelist_Response = CCloud_GetAppFileChangelist_Response {
            current_change_number: ::std::option::Option::None,
            files: ::std::vec::Vec::new(),
            is_only_delta: ::std::option::Option::None,
            path_prefixes: ::std::vec::Vec::new(),
            machine_names: ::std::vec::Vec::new(),
            app_buildid_hwm: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional uint64 client_id = 2;

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

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

    pub fn has_client_id(&self) -> bool {
        self.client_id.is_some()
    }

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

    // optional string machine_name = 3;

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

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

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

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

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

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

    // optional bool cloud_sync_completed = 4;

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

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

    pub fn has_cloud_sync_completed(&self) -> bool {
        self.cloud_sync_completed.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_AppSessionSuspend_Request {
    const NAME: &'static str = "CCloud_AppSessionSuspend_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.client_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                26 => {
                    self.machine_name = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.cloud_sync_completed = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.client_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.machine_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.cloud_sync_completed {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.client_id {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.machine_name.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.cloud_sync_completed {
            os.write_bool(4, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional uint32 appid = 1;

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

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

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

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

    // optional uint64 client_id = 2;

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

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

    pub fn has_client_id(&self) -> bool {
        self.client_id.is_some()
    }

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

impl ::steam_vent_proto_common::protobuf::Message for CCloud_AppSessionResume_Request {
    const NAME: &'static str = "CCloud_AppSessionResume_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.client_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.client_id {
            os.write_uint64(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() -> CCloud_AppSessionResume_Request {
        CCloud_AppSessionResume_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.client_id = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_AppSessionResume_Request {
        static instance: CCloud_AppSessionResume_Request = CCloud_AppSessionResume_Request {
            appid: ::std::option::Option::None,
            client_id: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CCloud_AppSessionResume_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_AppSessionResume_Response {
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_AppSessionResume_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CCloud_AppSessionResume_Response {
    fn default() -> &'a CCloud_AppSessionResume_Response {
        <CCloud_AppSessionResume_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CCloud_AppSessionResume_Response {
    pub fn new() -> CCloud_AppSessionResume_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CCloud_AppSessionResume_Response {
    const NAME: &'static str = "CCloud_AppSessionResume_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() -> CCloud_AppSessionResume_Response {
        CCloud_AppSessionResume_Response::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_AppSessionResume_Response {
        static instance: CCloud_AppSessionResume_Response = CCloud_AppSessionResume_Response {
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CCloud_AppLaunchIntent_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_AppLaunchIntent_Request {
    // message fields
    // @@protoc_insertion_point(field:CCloud_AppLaunchIntent_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_AppLaunchIntent_Request.client_id)
    pub client_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_AppLaunchIntent_Request.machine_name)
    pub machine_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CCloud_AppLaunchIntent_Request.ignore_pending_operations)
    pub ignore_pending_operations: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_AppLaunchIntent_Request.os_type)
    pub os_type: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CCloud_AppLaunchIntent_Request.device_type)
    pub device_type: ::std::option::Option<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_AppLaunchIntent_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CCloud_AppLaunchIntent_Request {
    fn default() -> &'a CCloud_AppLaunchIntent_Request {
        <CCloud_AppLaunchIntent_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CCloud_AppLaunchIntent_Request {
    pub fn new() -> CCloud_AppLaunchIntent_Request {
        ::std::default::Default::default()
    }

    // optional uint32 appid = 1;

    pub fn appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }

    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

    pub fn has_appid(&self) -> bool {
        self.appid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_appid(&mut self, v: u32) {
        self.appid = ::std::option::Option::Some(v);
    }

    // optional uint64 client_id = 2;

    pub fn client_id(&self) -> u64 {
        self.client_id.unwrap_or(0)
    }

    pub fn clear_client_id(&mut self) {
        self.client_id = ::std::option::Option::None;
    }

    pub fn has_client_id(&self) -> bool {
        self.client_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_client_id(&mut self, v: u64) {
        self.client_id = ::std::option::Option::Some(v);
    }

    // optional string machine_name = 3;

    pub fn machine_name(&self) -> &str {
        match self.machine_name.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_machine_name(&mut self) {
        self.machine_name = ::std::option::Option::None;
    }

    pub fn has_machine_name(&self) -> bool {
        self.machine_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_machine_name(&mut self, v: ::std::string::String) {
        self.machine_name = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_machine_name(&mut self) -> &mut ::std::string::String {
        if self.machine_name.is_none() {
            self.machine_name = ::std::option::Option::Some(::std::string::String::new());
        }
        self.machine_name.as_mut().unwrap()
    }

    // Take field
    pub fn take_machine_name(&mut self) -> ::std::string::String {
        self.machine_name.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional bool ignore_pending_operations = 4;

    pub fn ignore_pending_operations(&self) -> bool {
        self.ignore_pending_operations.unwrap_or(false)
    }

    pub fn clear_ignore_pending_operations(&mut self) {
        self.ignore_pending_operations = ::std::option::Option::None;
    }

    pub fn has_ignore_pending_operations(&self) -> bool {
        self.ignore_pending_operations.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ignore_pending_operations(&mut self, v: bool) {
        self.ignore_pending_operations = ::std::option::Option::Some(v);
    }

    // optional int32 os_type = 5;

    pub fn os_type(&self) -> i32 {
        self.os_type.unwrap_or(0)
    }

    pub fn clear_os_type(&mut self) {
        self.os_type = ::std::option::Option::None;
    }

    pub fn has_os_type(&self) -> bool {
        self.os_type.is_some()
    }

    // Param is passed by value, moved
    pub fn set_os_type(&mut self, v: i32) {
        self.os_type = ::std::option::Option::Some(v);
    }

    // optional int32 device_type = 6;

    pub fn device_type(&self) -> i32 {
        self.device_type.unwrap_or(0)
    }

    pub fn clear_device_type(&mut self) {
        self.device_type = ::std::option::Option::None;
    }

    pub fn has_device_type(&self) -> bool {
        self.device_type.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device_type(&mut self, v: i32) {
        self.device_type = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CCloud_AppLaunchIntent_Request {
    const NAME: &'static str = "CCloud_AppLaunchIntent_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.client_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                26 => {
                    self.machine_name = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.ignore_pending_operations = ::std::option::Option::Some(is.read_bool()?);
                },
                40 => {
                    self.os_type = ::std::option::Option::Some(is.read_int32()?);
                },
                48 => {
                    self.device_type = ::std::option::Option::Some(is.read_int32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.client_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.machine_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.ignore_pending_operations {
            my_size += 1 + 1;
        }
        if let Some(v) = self.os_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v);
        }
        if let Some(v) = self.device_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(6, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.client_id {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.machine_name.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.ignore_pending_operations {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.os_type {
            os.write_int32(5, v)?;
        }
        if let Some(v) = self.device_type {
            os.write_int32(6, 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() -> CCloud_AppLaunchIntent_Request {
        CCloud_AppLaunchIntent_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.client_id = ::std::option::Option::None;
        self.machine_name = ::std::option::Option::None;
        self.ignore_pending_operations = ::std::option::Option::None;
        self.os_type = ::std::option::Option::None;
        self.device_type = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_AppLaunchIntent_Request {
        static instance: CCloud_AppLaunchIntent_Request = CCloud_AppLaunchIntent_Request {
            appid: ::std::option::Option::None,
            client_id: ::std::option::Option::None,
            machine_name: ::std::option::Option::None,
            ignore_pending_operations: ::std::option::Option::None,
            os_type: ::std::option::Option::None,
            device_type: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CCloud_AppLaunchIntent_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_AppLaunchIntent_Response {
    // message fields
    // @@protoc_insertion_point(field:CCloud_AppLaunchIntent_Response.pending_remote_operations)
    pub pending_remote_operations: ::std::vec::Vec<super::steammessages_client_objects::CCloud_PendingRemoteOperation>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_AppLaunchIntent_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CCloud_AppLaunchIntent_Response {
    fn default() -> &'a CCloud_AppLaunchIntent_Response {
        <CCloud_AppLaunchIntent_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CCloud_AppLaunchIntent_Response {
    pub fn new() -> CCloud_AppLaunchIntent_Response {
        ::std::default::Default::default()
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CCloud_AppLaunchIntent_Response {
    const NAME: &'static str = "CCloud_AppLaunchIntent_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.pending_remote_operations.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.pending_remote_operations {
            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.pending_remote_operations {
            ::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() -> CCloud_AppLaunchIntent_Response {
        CCloud_AppLaunchIntent_Response::new()
    }

    fn clear(&mut self) {
        self.pending_remote_operations.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_AppLaunchIntent_Response {
        static instance: CCloud_AppLaunchIntent_Response = CCloud_AppLaunchIntent_Response {
            pending_remote_operations: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CCloud_AppExitSyncDone_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_AppExitSyncDone_Notification {
    // message fields
    // @@protoc_insertion_point(field:CCloud_AppExitSyncDone_Notification.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_AppExitSyncDone_Notification.client_id)
    pub client_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_AppExitSyncDone_Notification.uploads_completed)
    pub uploads_completed: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CCloud_AppExitSyncDone_Notification.uploads_required)
    pub uploads_required: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_AppExitSyncDone_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CCloud_AppExitSyncDone_Notification {
    fn default() -> &'a CCloud_AppExitSyncDone_Notification {
        <CCloud_AppExitSyncDone_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CCloud_AppExitSyncDone_Notification {
    pub fn new() -> CCloud_AppExitSyncDone_Notification {
        ::std::default::Default::default()
    }

    // optional uint32 appid = 1;

    pub fn appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }

    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

    pub fn has_appid(&self) -> bool {
        self.appid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_appid(&mut self, v: u32) {
        self.appid = ::std::option::Option::Some(v);
    }

    // optional uint64 client_id = 2;

    pub fn client_id(&self) -> u64 {
        self.client_id.unwrap_or(0)
    }

    pub fn clear_client_id(&mut self) {
        self.client_id = ::std::option::Option::None;
    }

    pub fn has_client_id(&self) -> bool {
        self.client_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_client_id(&mut self, v: u64) {
        self.client_id = ::std::option::Option::Some(v);
    }

    // optional bool uploads_completed = 3;

    pub fn uploads_completed(&self) -> bool {
        self.uploads_completed.unwrap_or(false)
    }

    pub fn clear_uploads_completed(&mut self) {
        self.uploads_completed = ::std::option::Option::None;
    }

    pub fn has_uploads_completed(&self) -> bool {
        self.uploads_completed.is_some()
    }

    // Param is passed by value, moved
    pub fn set_uploads_completed(&mut self, v: bool) {
        self.uploads_completed = ::std::option::Option::Some(v);
    }

    // optional bool uploads_required = 4;

    pub fn uploads_required(&self) -> bool {
        self.uploads_required.unwrap_or(false)
    }

    pub fn clear_uploads_required(&mut self) {
        self.uploads_required = ::std::option::Option::None;
    }

    pub fn has_uploads_required(&self) -> bool {
        self.uploads_required.is_some()
    }

    // Param is passed by value, moved
    pub fn set_uploads_required(&mut self, v: bool) {
        self.uploads_required = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CCloud_AppExitSyncDone_Notification {
    const NAME: &'static str = "CCloud_AppExitSyncDone_Notification";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.client_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.uploads_completed = ::std::option::Option::Some(is.read_bool()?);
                },
                32 => {
                    self.uploads_required = ::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.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.client_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.uploads_completed {
            my_size += 1 + 1;
        }
        if let Some(v) = self.uploads_required {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.client_id {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.uploads_completed {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.uploads_required {
            os.write_bool(4, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> CCloud_AppExitSyncDone_Notification {
        CCloud_AppExitSyncDone_Notification::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.client_id = ::std::option::Option::None;
        self.uploads_completed = ::std::option::Option::None;
        self.uploads_required = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_AppExitSyncDone_Notification {
        static instance: CCloud_AppExitSyncDone_Notification = CCloud_AppExitSyncDone_Notification {
            appid: ::std::option::Option::None,
            client_id: ::std::option::Option::None,
            uploads_completed: ::std::option::Option::None,
            uploads_required: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CCloud_ClientGetAppQuotaUsage_Request)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_ClientGetAppQuotaUsage_Request {
    // message fields
    // @@protoc_insertion_point(field:CCloud_ClientGetAppQuotaUsage_Request.appid)
    pub appid: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_ClientGetAppQuotaUsage_Request.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CCloud_ClientGetAppQuotaUsage_Request {
    fn default() -> &'a CCloud_ClientGetAppQuotaUsage_Request {
        <CCloud_ClientGetAppQuotaUsage_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CCloud_ClientGetAppQuotaUsage_Request {
    pub fn new() -> CCloud_ClientGetAppQuotaUsage_Request {
        ::std::default::Default::default()
    }

    // optional uint32 appid = 1;

    pub fn appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }

    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

    pub fn has_appid(&self) -> bool {
        self.appid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_appid(&mut self, v: u32) {
        self.appid = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CCloud_ClientGetAppQuotaUsage_Request {
    const NAME: &'static str = "CCloud_ClientGetAppQuotaUsage_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.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            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.appid {
            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() -> CCloud_ClientGetAppQuotaUsage_Request {
        CCloud_ClientGetAppQuotaUsage_Request::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_ClientGetAppQuotaUsage_Request {
        static instance: CCloud_ClientGetAppQuotaUsage_Request = CCloud_ClientGetAppQuotaUsage_Request {
            appid: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CCloud_ClientGetAppQuotaUsage_Response)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_ClientGetAppQuotaUsage_Response {
    // message fields
    // @@protoc_insertion_point(field:CCloud_ClientGetAppQuotaUsage_Response.existing_files)
    pub existing_files: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ClientGetAppQuotaUsage_Response.existing_bytes)
    pub existing_bytes: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CCloud_ClientGetAppQuotaUsage_Response.max_num_files)
    pub max_num_files: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_ClientGetAppQuotaUsage_Response.max_num_bytes)
    pub max_num_bytes: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_ClientGetAppQuotaUsage_Response.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CCloud_ClientGetAppQuotaUsage_Response {
    fn default() -> &'a CCloud_ClientGetAppQuotaUsage_Response {
        <CCloud_ClientGetAppQuotaUsage_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CCloud_ClientGetAppQuotaUsage_Response {
    pub fn new() -> CCloud_ClientGetAppQuotaUsage_Response {
        ::std::default::Default::default()
    }

    // optional uint32 existing_files = 1;

    pub fn existing_files(&self) -> u32 {
        self.existing_files.unwrap_or(0)
    }

    pub fn clear_existing_files(&mut self) {
        self.existing_files = ::std::option::Option::None;
    }

    pub fn has_existing_files(&self) -> bool {
        self.existing_files.is_some()
    }

    // Param is passed by value, moved
    pub fn set_existing_files(&mut self, v: u32) {
        self.existing_files = ::std::option::Option::Some(v);
    }

    // optional uint64 existing_bytes = 2;

    pub fn existing_bytes(&self) -> u64 {
        self.existing_bytes.unwrap_or(0)
    }

    pub fn clear_existing_bytes(&mut self) {
        self.existing_bytes = ::std::option::Option::None;
    }

    pub fn has_existing_bytes(&self) -> bool {
        self.existing_bytes.is_some()
    }

    // Param is passed by value, moved
    pub fn set_existing_bytes(&mut self, v: u64) {
        self.existing_bytes = ::std::option::Option::Some(v);
    }

    // optional uint32 max_num_files = 3;

    pub fn max_num_files(&self) -> u32 {
        self.max_num_files.unwrap_or(0)
    }

    pub fn clear_max_num_files(&mut self) {
        self.max_num_files = ::std::option::Option::None;
    }

    pub fn has_max_num_files(&self) -> bool {
        self.max_num_files.is_some()
    }

    // Param is passed by value, moved
    pub fn set_max_num_files(&mut self, v: u32) {
        self.max_num_files = ::std::option::Option::Some(v);
    }

    // optional uint64 max_num_bytes = 4;

    pub fn max_num_bytes(&self) -> u64 {
        self.max_num_bytes.unwrap_or(0)
    }

    pub fn clear_max_num_bytes(&mut self) {
        self.max_num_bytes = ::std::option::Option::None;
    }

    pub fn has_max_num_bytes(&self) -> bool {
        self.max_num_bytes.is_some()
    }

    // Param is passed by value, moved
    pub fn set_max_num_bytes(&mut self, v: u64) {
        self.max_num_bytes = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CCloud_ClientGetAppQuotaUsage_Response {
    const NAME: &'static str = "CCloud_ClientGetAppQuotaUsage_Response";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.existing_files = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.existing_bytes = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.max_num_files = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.max_num_bytes = ::std::option::Option::Some(is.read_uint64()?);
                },
                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.existing_files {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.existing_bytes {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.max_num_files {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.max_num_bytes {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.existing_files {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.existing_bytes {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.max_num_files {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.max_num_bytes {
            os.write_uint64(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() -> CCloud_ClientGetAppQuotaUsage_Response {
        CCloud_ClientGetAppQuotaUsage_Response::new()
    }

    fn clear(&mut self) {
        self.existing_files = ::std::option::Option::None;
        self.existing_bytes = ::std::option::Option::None;
        self.max_num_files = ::std::option::Option::None;
        self.max_num_bytes = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_ClientGetAppQuotaUsage_Response {
        static instance: CCloud_ClientGetAppQuotaUsage_Response = CCloud_ClientGetAppQuotaUsage_Response {
            existing_files: ::std::option::Option::None,
            existing_bytes: ::std::option::Option::None,
            max_num_files: ::std::option::Option::None,
            max_num_bytes: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CCloud_AppCloudStateChange_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_AppCloudStateChange_Notification {
    // message fields
    // @@protoc_insertion_point(field:CCloud_AppCloudStateChange_Notification.appid)
    pub appid: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CCloud_AppCloudStateChange_Notification.app_change_number)
    pub app_change_number: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_AppCloudStateChange_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CCloud_AppCloudStateChange_Notification {
    fn default() -> &'a CCloud_AppCloudStateChange_Notification {
        <CCloud_AppCloudStateChange_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CCloud_AppCloudStateChange_Notification {
    pub fn new() -> CCloud_AppCloudStateChange_Notification {
        ::std::default::Default::default()
    }

    // optional uint32 appid = 1;

    pub fn appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }

    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

    pub fn has_appid(&self) -> bool {
        self.appid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_appid(&mut self, v: u32) {
        self.appid = ::std::option::Option::Some(v);
    }

    // optional uint64 app_change_number = 2;

    pub fn app_change_number(&self) -> u64 {
        self.app_change_number.unwrap_or(0)
    }

    pub fn clear_app_change_number(&mut self) {
        self.app_change_number = ::std::option::Option::None;
    }

    pub fn has_app_change_number(&self) -> bool {
        self.app_change_number.is_some()
    }

    // Param is passed by value, moved
    pub fn set_app_change_number(&mut self, v: u64) {
        self.app_change_number = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CCloud_AppCloudStateChange_Notification {
    const NAME: &'static str = "CCloud_AppCloudStateChange_Notification";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.appid = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.app_change_number = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.app_change_number {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.app_change_number {
            os.write_uint64(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() -> CCloud_AppCloudStateChange_Notification {
        CCloud_AppCloudStateChange_Notification::new()
    }

    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.app_change_number = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_AppCloudStateChange_Notification {
        static instance: CCloud_AppCloudStateChange_Notification = CCloud_AppCloudStateChange_Notification {
            appid: ::std::option::Option::None,
            app_change_number: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CCloud_ClientLogUploadRequest_Notification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CCloud_ClientLogUploadRequest_Notification {
    // message fields
    // @@protoc_insertion_point(field:CCloud_ClientLogUploadRequest_Notification.request_id)
    pub request_id: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:CCloud_ClientLogUploadRequest_Notification.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a CCloud_ClientLogUploadRequest_Notification {
    fn default() -> &'a CCloud_ClientLogUploadRequest_Notification {
        <CCloud_ClientLogUploadRequest_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
    }
}

impl CCloud_ClientLogUploadRequest_Notification {
    pub fn new() -> CCloud_ClientLogUploadRequest_Notification {
        ::std::default::Default::default()
    }

    // optional uint64 request_id = 1;

    pub fn request_id(&self) -> u64 {
        self.request_id.unwrap_or(0)
    }

    pub fn clear_request_id(&mut self) {
        self.request_id = ::std::option::Option::None;
    }

    pub fn has_request_id(&self) -> bool {
        self.request_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_request_id(&mut self, v: u64) {
        self.request_id = ::std::option::Option::Some(v);
    }
}

impl ::steam_vent_proto_common::protobuf::Message for CCloud_ClientLogUploadRequest_Notification {
    const NAME: &'static str = "CCloud_ClientLogUploadRequest_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.request_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                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.request_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_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.request_id {
            os.write_uint64(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() -> CCloud_ClientLogUploadRequest_Notification {
        CCloud_ClientLogUploadRequest_Notification::new()
    }

    fn clear(&mut self) {
        self.request_id = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CCloud_ClientLogUploadRequest_Notification {
        static instance: CCloud_ClientLogUploadRequest_Notification = CCloud_ClientLogUploadRequest_Notification {
            request_id: ::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::enums::*;
#[allow(unused_imports)]
use crate::steammessages_client_objects::*;
impl ::steam_vent_proto_common::RpcMessage for CCloud_ClientLogUploadCheck_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 CCloud_ClientLogUploadComplete_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 CCloud_BeginHTTPUpload_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 CCloud_BeginHTTPUpload_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 CCloud_CommitHTTPUpload_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 CCloud_CommitHTTPUpload_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 CCloud_BeginUGCUpload_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 CCloud_BeginUGCUpload_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 CCloud_CommitUGCUpload_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 CCloud_CommitUGCUpload_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 CCloud_GetFileDetails_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 CCloud_UserFile {
    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 CCloud_GetFileDetails_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 CCloud_EnumerateUserFiles_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 CCloud_EnumerateUserFiles_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 CCloud_Delete_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 CCloud_Delete_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 CCloud_GetClientEncryptionKey_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 CCloud_GetClientEncryptionKey_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 CCloud_CDNReport_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 CCloud_ExternalStorageTransferReport_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 CCloud_BeginAppUploadBatch_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 CCloud_BeginAppUploadBatch_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 CCloud_CompleteAppUploadBatch_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 CCloud_CompleteAppUploadBatch_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 CCloud_CompleteAppUploadBatch_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 CCloud_ClientBeginFileUpload_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 ClientCloudFileUploadBlockDetails {
    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 CCloud_ClientBeginFileUpload_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 CCloud_ClientCommitFileUpload_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 CCloud_ClientCommitFileUpload_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 CCloud_ClientFileDownload_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 CCloud_ClientFileDownload_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 CCloud_ClientDeleteFile_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 CCloud_ClientDeleteFile_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 CCloud_ClientConflictResolution_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 CCloud_GetAppFileChangelist_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 CCloud_AppFileInfo {
    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 CCloud_GetAppFileChangelist_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 CCloud_AppSessionSuspend_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 CCloud_AppSessionSuspend_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 CCloud_AppSessionResume_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 CCloud_AppSessionResume_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 CCloud_AppLaunchIntent_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 CCloud_AppLaunchIntent_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 CCloud_AppExitSyncDone_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 CCloud_ClientGetAppQuotaUsage_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 CCloud_ClientGetAppQuotaUsage_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 CCloud_AppCloudStateChange_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 CCloud_ClientLogUploadRequest_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 Cloud {}
impl ::steam_vent_proto_common::RpcService for Cloud {
    const SERVICE_NAME: &'static str = "Cloud";
}
///
struct CloudClient {}
impl ::steam_vent_proto_common::RpcService for CloudClient {
    const SERVICE_NAME: &'static str = "CloudClient";
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_AppCloudStateChange_Notification {
    const METHOD_NAME: &'static str = "CloudClient.NotifyAppStateChange#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_AppExitSyncDone_Notification {
    const METHOD_NAME: &'static str = "Cloud.SignalAppExitSyncDone#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_AppLaunchIntent_Request {
    const METHOD_NAME: &'static str = "Cloud.SignalAppLaunchIntent#1";
    type Response = CCloud_AppLaunchIntent_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_AppSessionResume_Request {
    const METHOD_NAME: &'static str = "Cloud.ResumeAppSession#1";
    type Response = CCloud_AppSessionResume_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_AppSessionSuspend_Request {
    const METHOD_NAME: &'static str = "Cloud.SuspendAppSession#1";
    type Response = CCloud_AppSessionSuspend_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_BeginAppUploadBatch_Request {
    const METHOD_NAME: &'static str = "Cloud.BeginAppUploadBatch#1";
    type Response = CCloud_BeginAppUploadBatch_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_BeginHTTPUpload_Request {
    const METHOD_NAME: &'static str = "Cloud.BeginHTTPUpload#1";
    type Response = CCloud_BeginHTTPUpload_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_BeginUGCUpload_Request {
    const METHOD_NAME: &'static str = "Cloud.BeginUGCUpload#1";
    type Response = CCloud_BeginUGCUpload_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_CDNReport_Notification {
    const METHOD_NAME: &'static str = "Cloud.CDNReport#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_ClientBeginFileUpload_Request {
    const METHOD_NAME: &'static str = "Cloud.ClientBeginFileUpload#1";
    type Response = CCloud_ClientBeginFileUpload_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_ClientCommitFileUpload_Request {
    const METHOD_NAME: &'static str = "Cloud.ClientCommitFileUpload#1";
    type Response = CCloud_ClientCommitFileUpload_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CCloud_ClientConflictResolution_Notification {
    const METHOD_NAME: &'static str = "Cloud.ClientConflictResolution#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_ClientDeleteFile_Request {
    const METHOD_NAME: &'static str = "Cloud.ClientDeleteFile#1";
    type Response = CCloud_ClientDeleteFile_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_ClientFileDownload_Request {
    const METHOD_NAME: &'static str = "Cloud.ClientFileDownload#1";
    type Response = CCloud_ClientFileDownload_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_ClientGetAppQuotaUsage_Request {
    const METHOD_NAME: &'static str = "Cloud.ClientGetAppQuotaUsage#1";
    type Response = CCloud_ClientGetAppQuotaUsage_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_ClientLogUploadCheck_Notification {
    const METHOD_NAME: &'static str = "Cloud.ClientLogUploadCheck#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod
for CCloud_ClientLogUploadComplete_Notification {
    const METHOD_NAME: &'static str = "Cloud.ClientLogUploadComplete#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod
for CCloud_ClientLogUploadRequest_Notification {
    const METHOD_NAME: &'static str = "CloudClient.ClientLogUploadRequest#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_CommitHTTPUpload_Request {
    const METHOD_NAME: &'static str = "Cloud.CommitHTTPUpload#1";
    type Response = CCloud_CommitHTTPUpload_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_CommitUGCUpload_Request {
    const METHOD_NAME: &'static str = "Cloud.CommitUGCUpload#1";
    type Response = CCloud_CommitUGCUpload_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CCloud_CompleteAppUploadBatch_Notification {
    const METHOD_NAME: &'static str = "Cloud.CompleteAppUploadBatch#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_CompleteAppUploadBatch_Request {
    const METHOD_NAME: &'static str = "Cloud.CompleteAppUploadBatchBlocking#1";
    type Response = CCloud_CompleteAppUploadBatch_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_Delete_Request {
    const METHOD_NAME: &'static str = "Cloud.Delete#1";
    type Response = CCloud_Delete_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_EnumerateUserFiles_Request {
    const METHOD_NAME: &'static str = "Cloud.EnumerateUserFiles#1";
    type Response = CCloud_EnumerateUserFiles_Response;
}
impl ::steam_vent_proto_common::RpcMethod
for CCloud_ExternalStorageTransferReport_Notification {
    const METHOD_NAME: &'static str = "Cloud.ExternalStorageTransferReport#1";
    type Response = ();
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_GetAppFileChangelist_Request {
    const METHOD_NAME: &'static str = "Cloud.GetAppFileChangelist#1";
    type Response = CCloud_GetAppFileChangelist_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_GetClientEncryptionKey_Request {
    const METHOD_NAME: &'static str = "Cloud.GetClientEncryptionKey#1";
    type Response = CCloud_GetClientEncryptionKey_Response;
}
impl ::steam_vent_proto_common::RpcMethod for CCloud_GetFileDetails_Request {
    const METHOD_NAME: &'static str = "Cloud.GetFileDetails#1";
    type Response = CCloud_GetFileDetails_Response;
}
