steam-vent-proto 0.1.0

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ContentManifestPayload {
    // message fields
    pub mappings: ::protobuf::RepeatedField<ContentManifestPayload_FileMapping>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .ContentManifestPayload.FileMapping mappings = 1;


    pub fn get_mappings(&self) -> &[ContentManifestPayload_FileMapping] {
        &self.mappings
    }
    pub fn clear_mappings(&mut self) {
        self.mappings.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_mappings(&mut self) -> &mut ::protobuf::RepeatedField<ContentManifestPayload_FileMapping> {
        &mut self.mappings
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ContentManifestPayload_FileMapping {
    // message fields
    filename: ::protobuf::SingularField<::std::string::String>,
    size: ::std::option::Option<u64>,
    flags: ::std::option::Option<u32>,
    sha_filename: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    sha_content: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    pub chunks: ::protobuf::RepeatedField<ContentManifestPayload_FileMapping_ChunkData>,
    linktarget: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string filename = 1;


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

    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 = ::protobuf::SingularField::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.set_default();
        }
        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 size = 2;


    pub fn get_size(&self) -> u64 {
        self.size.unwrap_or(0)
    }
    pub fn clear_size(&mut self) {
        self.size = ::std::option::Option::None;
    }

    pub fn has_size(&self) -> bool {
        self.size.is_some()
    }

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

    // optional uint32 flags = 3;


    pub fn get_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 bytes sha_filename = 4;


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

    pub fn has_sha_filename(&self) -> bool {
        self.sha_filename.is_some()
    }

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

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

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

    // optional bytes sha_content = 5;


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

    pub fn has_sha_content(&self) -> bool {
        self.sha_content.is_some()
    }

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

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

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

    // repeated .ContentManifestPayload.FileMapping.ChunkData chunks = 6;


    pub fn get_chunks(&self) -> &[ContentManifestPayload_FileMapping_ChunkData] {
        &self.chunks
    }
    pub fn clear_chunks(&mut self) {
        self.chunks.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_chunks(&mut self) -> &mut ::protobuf::RepeatedField<ContentManifestPayload_FileMapping_ChunkData> {
        &mut self.chunks
    }

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

    // optional string linktarget = 7;


    pub fn get_linktarget(&self) -> &str {
        match self.linktarget.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_linktarget(&mut self) {
        self.linktarget.clear();
    }

    pub fn has_linktarget(&self) -> bool {
        self.linktarget.is_some()
    }

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

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.filename)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.size = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.flags = ::std::option::Option::Some(tmp);
                },
                4 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.sha_filename)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.sha_content)?;
                },
                6 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.chunks)?;
                },
                7 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.linktarget)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.filename.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.size {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.flags {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.sha_filename.as_ref() {
            my_size += ::protobuf::rt::bytes_size(4, &v);
        }
        if let Some(ref v) = self.sha_content.as_ref() {
            my_size += ::protobuf::rt::bytes_size(5, &v);
        }
        for value in &self.chunks {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(ref v) = self.linktarget.as_ref() {
            my_size += ::protobuf::rt::string_size(7, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.filename.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(v) = self.size {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.flags {
            os.write_uint32(3, v)?;
        }
        if let Some(ref v) = self.sha_filename.as_ref() {
            os.write_bytes(4, &v)?;
        }
        if let Some(ref v) = self.sha_content.as_ref() {
            os.write_bytes(5, &v)?;
        }
        for v in &self.chunks {
            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(ref v) = self.linktarget.as_ref() {
            os.write_string(7, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "filename",
                |m: &ContentManifestPayload_FileMapping| { &m.filename },
                |m: &mut ContentManifestPayload_FileMapping| { &mut m.filename },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "size",
                |m: &ContentManifestPayload_FileMapping| { &m.size },
                |m: &mut ContentManifestPayload_FileMapping| { &mut m.size },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "flags",
                |m: &ContentManifestPayload_FileMapping| { &m.flags },
                |m: &mut ContentManifestPayload_FileMapping| { &mut m.flags },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "sha_filename",
                |m: &ContentManifestPayload_FileMapping| { &m.sha_filename },
                |m: &mut ContentManifestPayload_FileMapping| { &mut m.sha_filename },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "sha_content",
                |m: &ContentManifestPayload_FileMapping| { &m.sha_content },
                |m: &mut ContentManifestPayload_FileMapping| { &mut m.sha_content },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ContentManifestPayload_FileMapping_ChunkData>>(
                "chunks",
                |m: &ContentManifestPayload_FileMapping| { &m.chunks },
                |m: &mut ContentManifestPayload_FileMapping| { &mut m.chunks },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "linktarget",
                |m: &ContentManifestPayload_FileMapping| { &m.linktarget },
                |m: &mut ContentManifestPayload_FileMapping| { &mut m.linktarget },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ContentManifestPayload_FileMapping>(
                "ContentManifestPayload.FileMapping",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ContentManifestPayload_FileMapping {
    fn clear(&mut self) {
        self.filename.clear();
        self.size = ::std::option::Option::None;
        self.flags = ::std::option::Option::None;
        self.sha_filename.clear();
        self.sha_content.clear();
        self.chunks.clear();
        self.linktarget.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ContentManifestPayload_FileMapping_ChunkData {
    // message fields
    sha: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    crc: ::std::option::Option<u32>,
    offset: ::std::option::Option<u64>,
    cb_original: ::std::option::Option<u32>,
    cb_compressed: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bytes sha = 1;


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

    pub fn has_sha(&self) -> bool {
        self.sha.is_some()
    }

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

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

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

    // optional fixed32 crc = 2;


    pub fn get_crc(&self) -> u32 {
        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: u32) {
        self.crc = ::std::option::Option::Some(v);
    }

    // optional uint64 offset = 3;


    pub fn get_offset(&self) -> u64 {
        self.offset.unwrap_or(0)
    }
    pub fn clear_offset(&mut self) {
        self.offset = ::std::option::Option::None;
    }

    pub fn has_offset(&self) -> bool {
        self.offset.is_some()
    }

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

    // optional uint32 cb_original = 4;


    pub fn get_cb_original(&self) -> u32 {
        self.cb_original.unwrap_or(0)
    }
    pub fn clear_cb_original(&mut self) {
        self.cb_original = ::std::option::Option::None;
    }

    pub fn has_cb_original(&self) -> bool {
        self.cb_original.is_some()
    }

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

    // optional uint32 cb_compressed = 5;


    pub fn get_cb_compressed(&self) -> u32 {
        self.cb_compressed.unwrap_or(0)
    }
    pub fn clear_cb_compressed(&mut self) {
        self.cb_compressed = ::std::option::Option::None;
    }

    pub fn has_cb_compressed(&self) -> bool {
        self.cb_compressed.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.sha)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.crc = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.offset = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.cb_original = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.cb_compressed = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.sha.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(v) = self.crc {
            my_size += 5;
        }
        if let Some(v) = self.offset {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.cb_original {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.cb_compressed {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.sha.as_ref() {
            os.write_bytes(1, &v)?;
        }
        if let Some(v) = self.crc {
            os.write_fixed32(2, v)?;
        }
        if let Some(v) = self.offset {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.cb_original {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.cb_compressed {
            os.write_uint32(5, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "sha",
                |m: &ContentManifestPayload_FileMapping_ChunkData| { &m.sha },
                |m: &mut ContentManifestPayload_FileMapping_ChunkData| { &mut m.sha },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "crc",
                |m: &ContentManifestPayload_FileMapping_ChunkData| { &m.crc },
                |m: &mut ContentManifestPayload_FileMapping_ChunkData| { &mut m.crc },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "offset",
                |m: &ContentManifestPayload_FileMapping_ChunkData| { &m.offset },
                |m: &mut ContentManifestPayload_FileMapping_ChunkData| { &mut m.offset },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "cb_original",
                |m: &ContentManifestPayload_FileMapping_ChunkData| { &m.cb_original },
                |m: &mut ContentManifestPayload_FileMapping_ChunkData| { &mut m.cb_original },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "cb_compressed",
                |m: &ContentManifestPayload_FileMapping_ChunkData| { &m.cb_compressed },
                |m: &mut ContentManifestPayload_FileMapping_ChunkData| { &mut m.cb_compressed },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ContentManifestPayload_FileMapping_ChunkData>(
                "ContentManifestPayload.FileMapping.ChunkData",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ContentManifestPayload_FileMapping_ChunkData {
    fn clear(&mut self) {
        self.sha.clear();
        self.crc = ::std::option::Option::None;
        self.offset = ::std::option::Option::None;
        self.cb_original = ::std::option::Option::None;
        self.cb_compressed = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ContentManifestMetadata {
    // message fields
    depot_id: ::std::option::Option<u32>,
    gid_manifest: ::std::option::Option<u64>,
    creation_time: ::std::option::Option<u32>,
    filenames_encrypted: ::std::option::Option<bool>,
    cb_disk_original: ::std::option::Option<u64>,
    cb_disk_compressed: ::std::option::Option<u64>,
    unique_chunks: ::std::option::Option<u32>,
    crc_encrypted: ::std::option::Option<u32>,
    crc_clear: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 depot_id = 1;


    pub fn get_depot_id(&self) -> u32 {
        self.depot_id.unwrap_or(0)
    }
    pub fn clear_depot_id(&mut self) {
        self.depot_id = ::std::option::Option::None;
    }

    pub fn has_depot_id(&self) -> bool {
        self.depot_id.is_some()
    }

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

    // optional uint64 gid_manifest = 2;


    pub fn get_gid_manifest(&self) -> u64 {
        self.gid_manifest.unwrap_or(0)
    }
    pub fn clear_gid_manifest(&mut self) {
        self.gid_manifest = ::std::option::Option::None;
    }

    pub fn has_gid_manifest(&self) -> bool {
        self.gid_manifest.is_some()
    }

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

    // optional uint32 creation_time = 3;


    pub fn get_creation_time(&self) -> u32 {
        self.creation_time.unwrap_or(0)
    }
    pub fn clear_creation_time(&mut self) {
        self.creation_time = ::std::option::Option::None;
    }

    pub fn has_creation_time(&self) -> bool {
        self.creation_time.is_some()
    }

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

    // optional bool filenames_encrypted = 4;


    pub fn get_filenames_encrypted(&self) -> bool {
        self.filenames_encrypted.unwrap_or(false)
    }
    pub fn clear_filenames_encrypted(&mut self) {
        self.filenames_encrypted = ::std::option::Option::None;
    }

    pub fn has_filenames_encrypted(&self) -> bool {
        self.filenames_encrypted.is_some()
    }

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

    // optional uint64 cb_disk_original = 5;


    pub fn get_cb_disk_original(&self) -> u64 {
        self.cb_disk_original.unwrap_or(0)
    }
    pub fn clear_cb_disk_original(&mut self) {
        self.cb_disk_original = ::std::option::Option::None;
    }

    pub fn has_cb_disk_original(&self) -> bool {
        self.cb_disk_original.is_some()
    }

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

    // optional uint64 cb_disk_compressed = 6;


    pub fn get_cb_disk_compressed(&self) -> u64 {
        self.cb_disk_compressed.unwrap_or(0)
    }
    pub fn clear_cb_disk_compressed(&mut self) {
        self.cb_disk_compressed = ::std::option::Option::None;
    }

    pub fn has_cb_disk_compressed(&self) -> bool {
        self.cb_disk_compressed.is_some()
    }

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

    // optional uint32 unique_chunks = 7;


    pub fn get_unique_chunks(&self) -> u32 {
        self.unique_chunks.unwrap_or(0)
    }
    pub fn clear_unique_chunks(&mut self) {
        self.unique_chunks = ::std::option::Option::None;
    }

    pub fn has_unique_chunks(&self) -> bool {
        self.unique_chunks.is_some()
    }

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

    // optional uint32 crc_encrypted = 8;


    pub fn get_crc_encrypted(&self) -> u32 {
        self.crc_encrypted.unwrap_or(0)
    }
    pub fn clear_crc_encrypted(&mut self) {
        self.crc_encrypted = ::std::option::Option::None;
    }

    pub fn has_crc_encrypted(&self) -> bool {
        self.crc_encrypted.is_some()
    }

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

    // optional uint32 crc_clear = 9;


    pub fn get_crc_clear(&self) -> u32 {
        self.crc_clear.unwrap_or(0)
    }
    pub fn clear_crc_clear(&mut self) {
        self.crc_clear = ::std::option::Option::None;
    }

    pub fn has_crc_clear(&self) -> bool {
        self.crc_clear.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.depot_id = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.gid_manifest = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.creation_time = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.filenames_encrypted = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.cb_disk_original = ::std::option::Option::Some(tmp);
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.cb_disk_compressed = ::std::option::Option::Some(tmp);
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.unique_chunks = ::std::option::Option::Some(tmp);
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.crc_encrypted = ::std::option::Option::Some(tmp);
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.crc_clear = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.depot_id {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.gid_manifest {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.creation_time {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.filenames_encrypted {
            my_size += 2;
        }
        if let Some(v) = self.cb_disk_original {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.cb_disk_compressed {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.unique_chunks {
            my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.crc_encrypted {
            my_size += ::protobuf::rt::value_size(8, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.crc_clear {
            my_size += ::protobuf::rt::value_size(9, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.depot_id {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.gid_manifest {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.creation_time {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.filenames_encrypted {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.cb_disk_original {
            os.write_uint64(5, v)?;
        }
        if let Some(v) = self.cb_disk_compressed {
            os.write_uint64(6, v)?;
        }
        if let Some(v) = self.unique_chunks {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.crc_encrypted {
            os.write_uint32(8, v)?;
        }
        if let Some(v) = self.crc_clear {
            os.write_uint32(9, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "depot_id",
                |m: &ContentManifestMetadata| { &m.depot_id },
                |m: &mut ContentManifestMetadata| { &mut m.depot_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "gid_manifest",
                |m: &ContentManifestMetadata| { &m.gid_manifest },
                |m: &mut ContentManifestMetadata| { &mut m.gid_manifest },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "creation_time",
                |m: &ContentManifestMetadata| { &m.creation_time },
                |m: &mut ContentManifestMetadata| { &mut m.creation_time },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "filenames_encrypted",
                |m: &ContentManifestMetadata| { &m.filenames_encrypted },
                |m: &mut ContentManifestMetadata| { &mut m.filenames_encrypted },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "cb_disk_original",
                |m: &ContentManifestMetadata| { &m.cb_disk_original },
                |m: &mut ContentManifestMetadata| { &mut m.cb_disk_original },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "cb_disk_compressed",
                |m: &ContentManifestMetadata| { &m.cb_disk_compressed },
                |m: &mut ContentManifestMetadata| { &mut m.cb_disk_compressed },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "unique_chunks",
                |m: &ContentManifestMetadata| { &m.unique_chunks },
                |m: &mut ContentManifestMetadata| { &mut m.unique_chunks },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "crc_encrypted",
                |m: &ContentManifestMetadata| { &m.crc_encrypted },
                |m: &mut ContentManifestMetadata| { &mut m.crc_encrypted },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "crc_clear",
                |m: &ContentManifestMetadata| { &m.crc_clear },
                |m: &mut ContentManifestMetadata| { &mut m.crc_clear },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ContentManifestMetadata>(
                "ContentManifestMetadata",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ContentManifestMetadata {
    fn clear(&mut self) {
        self.depot_id = ::std::option::Option::None;
        self.gid_manifest = ::std::option::Option::None;
        self.creation_time = ::std::option::Option::None;
        self.filenames_encrypted = ::std::option::Option::None;
        self.cb_disk_original = ::std::option::Option::None;
        self.cb_disk_compressed = ::std::option::Option::None;
        self.unique_chunks = ::std::option::Option::None;
        self.crc_encrypted = ::std::option::Option::None;
        self.crc_clear = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional bytes signature = 1;


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ContentDeltaChunks {
    // message fields
    depot_id: ::std::option::Option<u32>,
    manifest_id_source: ::std::option::Option<u64>,
    manifest_id_target: ::std::option::Option<u64>,
    pub deltaChunks: ::protobuf::RepeatedField<ContentDeltaChunks_DeltaChunk>,
    chunk_data_location: ::std::option::Option<EContentDeltaChunkDataLocation>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 depot_id = 1;


    pub fn get_depot_id(&self) -> u32 {
        self.depot_id.unwrap_or(0)
    }
    pub fn clear_depot_id(&mut self) {
        self.depot_id = ::std::option::Option::None;
    }

    pub fn has_depot_id(&self) -> bool {
        self.depot_id.is_some()
    }

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

    // optional uint64 manifest_id_source = 2;


    pub fn get_manifest_id_source(&self) -> u64 {
        self.manifest_id_source.unwrap_or(0)
    }
    pub fn clear_manifest_id_source(&mut self) {
        self.manifest_id_source = ::std::option::Option::None;
    }

    pub fn has_manifest_id_source(&self) -> bool {
        self.manifest_id_source.is_some()
    }

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

    // optional uint64 manifest_id_target = 3;


    pub fn get_manifest_id_target(&self) -> u64 {
        self.manifest_id_target.unwrap_or(0)
    }
    pub fn clear_manifest_id_target(&mut self) {
        self.manifest_id_target = ::std::option::Option::None;
    }

    pub fn has_manifest_id_target(&self) -> bool {
        self.manifest_id_target.is_some()
    }

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

    // repeated .ContentDeltaChunks.DeltaChunk deltaChunks = 4;


    pub fn get_deltaChunks(&self) -> &[ContentDeltaChunks_DeltaChunk] {
        &self.deltaChunks
    }
    pub fn clear_deltaChunks(&mut self) {
        self.deltaChunks.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_deltaChunks(&mut self) -> &mut ::protobuf::RepeatedField<ContentDeltaChunks_DeltaChunk> {
        &mut self.deltaChunks
    }

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

    // optional .EContentDeltaChunkDataLocation chunk_data_location = 5;


    pub fn get_chunk_data_location(&self) -> EContentDeltaChunkDataLocation {
        self.chunk_data_location.unwrap_or(EContentDeltaChunkDataLocation::k_EContentDeltaChunkDataLocationInProtobuf)
    }
    pub fn clear_chunk_data_location(&mut self) {
        self.chunk_data_location = ::std::option::Option::None;
    }

    pub fn has_chunk_data_location(&self) -> bool {
        self.chunk_data_location.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.depot_id = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.manifest_id_source = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.manifest_id_target = ::std::option::Option::Some(tmp);
                },
                4 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.deltaChunks)?;
                },
                5 => {
                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.chunk_data_location, 5, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.depot_id {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.manifest_id_source {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.manifest_id_target {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.deltaChunks {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(v) = self.chunk_data_location {
            my_size += ::protobuf::rt::enum_size(5, v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.depot_id {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.manifest_id_source {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.manifest_id_target {
            os.write_uint64(3, v)?;
        }
        for v in &self.deltaChunks {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(v) = self.chunk_data_location {
            os.write_enum(5, ::protobuf::ProtobufEnum::value(&v))?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "depot_id",
                |m: &ContentDeltaChunks| { &m.depot_id },
                |m: &mut ContentDeltaChunks| { &mut m.depot_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "manifest_id_source",
                |m: &ContentDeltaChunks| { &m.manifest_id_source },
                |m: &mut ContentDeltaChunks| { &mut m.manifest_id_source },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "manifest_id_target",
                |m: &ContentDeltaChunks| { &m.manifest_id_target },
                |m: &mut ContentDeltaChunks| { &mut m.manifest_id_target },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ContentDeltaChunks_DeltaChunk>>(
                "deltaChunks",
                |m: &ContentDeltaChunks| { &m.deltaChunks },
                |m: &mut ContentDeltaChunks| { &mut m.deltaChunks },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EContentDeltaChunkDataLocation>>(
                "chunk_data_location",
                |m: &ContentDeltaChunks| { &m.chunk_data_location },
                |m: &mut ContentDeltaChunks| { &mut m.chunk_data_location },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ContentDeltaChunks>(
                "ContentDeltaChunks",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ContentDeltaChunks {
    fn clear(&mut self) {
        self.depot_id = ::std::option::Option::None;
        self.manifest_id_source = ::std::option::Option::None;
        self.manifest_id_target = ::std::option::Option::None;
        self.deltaChunks.clear();
        self.chunk_data_location = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ContentDeltaChunks_DeltaChunk {
    // message fields
    sha_source: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    sha_target: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    size_original: ::std::option::Option<u32>,
    patch_method: ::std::option::Option<u32>,
    chunk: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    size_delta: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bytes sha_source = 1;


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

    pub fn has_sha_source(&self) -> bool {
        self.sha_source.is_some()
    }

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

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

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

    // optional bytes sha_target = 2;


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

    pub fn has_sha_target(&self) -> bool {
        self.sha_target.is_some()
    }

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

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

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

    // optional uint32 size_original = 3;


    pub fn get_size_original(&self) -> u32 {
        self.size_original.unwrap_or(0)
    }
    pub fn clear_size_original(&mut self) {
        self.size_original = ::std::option::Option::None;
    }

    pub fn has_size_original(&self) -> bool {
        self.size_original.is_some()
    }

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

    // optional uint32 patch_method = 4;


    pub fn get_patch_method(&self) -> u32 {
        self.patch_method.unwrap_or(0)
    }
    pub fn clear_patch_method(&mut self) {
        self.patch_method = ::std::option::Option::None;
    }

    pub fn has_patch_method(&self) -> bool {
        self.patch_method.is_some()
    }

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

    // optional bytes chunk = 5;


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

    pub fn has_chunk(&self) -> bool {
        self.chunk.is_some()
    }

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

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

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

    // optional uint32 size_delta = 6;


    pub fn get_size_delta(&self) -> u32 {
        self.size_delta.unwrap_or(0)
    }
    pub fn clear_size_delta(&mut self) {
        self.size_delta = ::std::option::Option::None;
    }

    pub fn has_size_delta(&self) -> bool {
        self.size_delta.is_some()
    }

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

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

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

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.sha_source.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(ref v) = self.sha_target.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(v) = self.size_original {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.patch_method {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.chunk.as_ref() {
            my_size += ::protobuf::rt::bytes_size(5, &v);
        }
        if let Some(v) = self.size_delta {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.sha_source.as_ref() {
            os.write_bytes(1, &v)?;
        }
        if let Some(ref v) = self.sha_target.as_ref() {
            os.write_bytes(2, &v)?;
        }
        if let Some(v) = self.size_original {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.patch_method {
            os.write_uint32(4, v)?;
        }
        if let Some(ref v) = self.chunk.as_ref() {
            os.write_bytes(5, &v)?;
        }
        if let Some(v) = self.size_delta {
            os.write_uint32(6, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "sha_source",
                |m: &ContentDeltaChunks_DeltaChunk| { &m.sha_source },
                |m: &mut ContentDeltaChunks_DeltaChunk| { &mut m.sha_source },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "sha_target",
                |m: &ContentDeltaChunks_DeltaChunk| { &m.sha_target },
                |m: &mut ContentDeltaChunks_DeltaChunk| { &mut m.sha_target },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "size_original",
                |m: &ContentDeltaChunks_DeltaChunk| { &m.size_original },
                |m: &mut ContentDeltaChunks_DeltaChunk| { &mut m.size_original },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "patch_method",
                |m: &ContentDeltaChunks_DeltaChunk| { &m.patch_method },
                |m: &mut ContentDeltaChunks_DeltaChunk| { &mut m.patch_method },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "chunk",
                |m: &ContentDeltaChunks_DeltaChunk| { &m.chunk },
                |m: &mut ContentDeltaChunks_DeltaChunk| { &mut m.chunk },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "size_delta",
                |m: &ContentDeltaChunks_DeltaChunk| { &m.size_delta },
                |m: &mut ContentDeltaChunks_DeltaChunk| { &mut m.size_delta },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ContentDeltaChunks_DeltaChunk>(
                "ContentDeltaChunks.DeltaChunk",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ContentDeltaChunks_DeltaChunk {
    fn clear(&mut self) {
        self.sha_source.clear();
        self.sha_target.clear();
        self.size_original = ::std::option::Option::None;
        self.patch_method = ::std::option::Option::None;
        self.chunk.clear();
        self.size_delta = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum EContentDeltaChunkDataLocation {
    k_EContentDeltaChunkDataLocationInProtobuf = 0,
    k_EContentDeltaChunkDataLocationAfterProtobuf = 1,
}

impl ::protobuf::ProtobufEnum for EContentDeltaChunkDataLocation {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<EContentDeltaChunkDataLocation> {
        match value {
            0 => ::std::option::Option::Some(EContentDeltaChunkDataLocation::k_EContentDeltaChunkDataLocationInProtobuf),
            1 => ::std::option::Option::Some(EContentDeltaChunkDataLocation::k_EContentDeltaChunkDataLocationAfterProtobuf),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [EContentDeltaChunkDataLocation] = &[
            EContentDeltaChunkDataLocation::k_EContentDeltaChunkDataLocationInProtobuf,
            EContentDeltaChunkDataLocation::k_EContentDeltaChunkDataLocationAfterProtobuf,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<EContentDeltaChunkDataLocation>("EContentDeltaChunkDataLocation", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for EContentDeltaChunkDataLocation {
}

impl ::std::default::Default for EContentDeltaChunkDataLocation {
    fn default() -> Self {
        EContentDeltaChunkDataLocation::k_EContentDeltaChunkDataLocationInProtobuf
    }
}

impl ::protobuf::reflect::ProtobufValue for EContentDeltaChunkDataLocation {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x16content_manifest.proto\"\xea\x03\n\x16ContentManifestPayload\x12?\
    \n\x08mappings\x18\x01\x20\x03(\x0b2#.ContentManifestPayload.FileMapping\
    R\x08mappings\x1a\x8e\x03\n\x0bFileMapping\x12\x1a\n\x08filename\x18\x01\
    \x20\x01(\tR\x08filename\x12\x12\n\x04size\x18\x02\x20\x01(\x04R\x04size\
    \x12\x14\n\x05flags\x18\x03\x20\x01(\rR\x05flags\x12!\n\x0csha_filename\
    \x18\x04\x20\x01(\x0cR\x0bshaFilename\x12\x1f\n\x0bsha_content\x18\x05\
    \x20\x01(\x0cR\nshaContent\x12E\n\x06chunks\x18\x06\x20\x03(\x0b2-.Conte\
    ntManifestPayload.FileMapping.ChunkDataR\x06chunks\x12\x1e\n\nlinktarget\
    \x18\x07\x20\x01(\tR\nlinktarget\x1a\x8d\x01\n\tChunkData\x12\x10\n\x03s\
    ha\x18\x01\x20\x01(\x0cR\x03sha\x12\x10\n\x03crc\x18\x02\x20\x01(\x07R\
    \x03crc\x12\x16\n\x06offset\x18\x03\x20\x01(\x04R\x06offset\x12\x1f\n\
    \x0bcb_original\x18\x04\x20\x01(\rR\ncbOriginal\x12#\n\rcb_compressed\
    \x18\x05\x20\x01(\rR\x0ccbCompressed\"\xec\x02\n\x17ContentManifestMetad\
    ata\x12\x19\n\x08depot_id\x18\x01\x20\x01(\rR\x07depotId\x12!\n\x0cgid_m\
    anifest\x18\x02\x20\x01(\x04R\x0bgidManifest\x12#\n\rcreation_time\x18\
    \x03\x20\x01(\rR\x0ccreationTime\x12/\n\x13filenames_encrypted\x18\x04\
    \x20\x01(\x08R\x12filenamesEncrypted\x12(\n\x10cb_disk_original\x18\x05\
    \x20\x01(\x04R\x0ecbDiskOriginal\x12,\n\x12cb_disk_compressed\x18\x06\
    \x20\x01(\x04R\x10cbDiskCompressed\x12#\n\runique_chunks\x18\x07\x20\x01\
    (\rR\x0cuniqueChunks\x12#\n\rcrc_encrypted\x18\x08\x20\x01(\rR\x0ccrcEnc\
    rypted\x12\x1b\n\tcrc_clear\x18\t\x20\x01(\rR\x08crcClear\"8\n\x18Conten\
    tManifestSignature\x12\x1c\n\tsignature\x18\x01\x20\x01(\x0cR\tsignature\
    \"\x94\x04\n\x12ContentDeltaChunks\x12\x19\n\x08depot_id\x18\x01\x20\x01\
    (\rR\x07depotId\x12,\n\x12manifest_id_source\x18\x02\x20\x01(\x04R\x10ma\
    nifestIdSource\x12,\n\x12manifest_id_target\x18\x03\x20\x01(\x04R\x10man\
    ifestIdTarget\x12@\n\x0bdeltaChunks\x18\x04\x20\x03(\x0b2\x1e.ContentDel\
    taChunks.DeltaChunkR\x0bdeltaChunks\x12{\n\x13chunk_data_location\x18\
    \x05\x20\x01(\x0e2\x1f.EContentDeltaChunkDataLocation:*k_EContentDeltaCh\
    unkDataLocationInProtobufR\x11chunkDataLocation\x1a\xc7\x01\n\nDeltaChun\
    k\x12\x1d\n\nsha_source\x18\x01\x20\x01(\x0cR\tshaSource\x12\x1d\n\nsha_\
    target\x18\x02\x20\x01(\x0cR\tshaTarget\x12#\n\rsize_original\x18\x03\
    \x20\x01(\rR\x0csizeOriginal\x12!\n\x0cpatch_method\x18\x04\x20\x01(\rR\
    \x0bpatchMethod\x12\x14\n\x05chunk\x18\x05\x20\x01(\x0cR\x05chunk\x12\
    \x1d\n\nsize_delta\x18\x06\x20\x01(\rR\tsizeDelta*\x83\x01\n\x1eEContent\
    DeltaChunkDataLocation\x12.\n*k_EContentDeltaChunkDataLocationInProtobuf\
    \x10\0\x121\n-k_EContentDeltaChunkDataLocationAfterProtobuf\x10\x01B\x05\
    H\x01\x80\x01\0J\x81\x17\n\x06\x12\x04\0\0=\x01\n\x08\n\x01\x08\x12\x03\
    \0\0\x1c\n\t\n\x02\x08\t\x12\x03\0\0\x1c\n\x08\n\x01\x08\x12\x03\x01\0#\
    \n\t\n\x02\x08\x10\x12\x03\x01\0#\n\n\n\x02\x05\0\x12\x04\x03\0\x06\x01\
    \n\n\n\x03\x05\0\x01\x12\x03\x03\x05#\n\x0b\n\x04\x05\0\x02\0\x12\x03\
    \x04\x087\n\x0c\n\x05\x05\0\x02\0\x01\x12\x03\x04\x082\n\x0c\n\x05\x05\0\
    \x02\0\x02\x12\x03\x0456\n\x0b\n\x04\x05\0\x02\x01\x12\x03\x05\x08:\n\
    \x0c\n\x05\x05\0\x02\x01\x01\x12\x03\x05\x085\n\x0c\n\x05\x05\0\x02\x01\
    \x02\x12\x03\x0589\n\n\n\x02\x04\0\x12\x04\x08\0\x1c\x01\n\n\n\x03\x04\0\
    \x01\x12\x03\x08\x08\x1e\n\x0c\n\x04\x04\0\x03\0\x12\x04\t\x08\x19\t\n\
    \x0c\n\x05\x04\0\x03\0\x01\x12\x03\t\x10\x1b\n\x0e\n\x06\x04\0\x03\0\x03\
    \0\x12\x04\n\x10\x10\x11\n\x0e\n\x07\x04\0\x03\0\x03\0\x01\x12\x03\n\x18\
    !\n\x0f\n\x08\x04\0\x03\0\x03\0\x02\0\x12\x03\x0b\x18/\n\x10\n\t\x04\0\
    \x03\0\x03\0\x02\0\x04\x12\x03\x0b\x18\x20\n\x10\n\t\x04\0\x03\0\x03\0\
    \x02\0\x05\x12\x03\x0b!&\n\x10\n\t\x04\0\x03\0\x03\0\x02\0\x01\x12\x03\
    \x0b'*\n\x10\n\t\x04\0\x03\0\x03\0\x02\0\x03\x12\x03\x0b-.\n\x0f\n\x08\
    \x04\0\x03\0\x03\0\x02\x01\x12\x03\x0c\x181\n\x10\n\t\x04\0\x03\0\x03\0\
    \x02\x01\x04\x12\x03\x0c\x18\x20\n\x10\n\t\x04\0\x03\0\x03\0\x02\x01\x05\
    \x12\x03\x0c!(\n\x10\n\t\x04\0\x03\0\x03\0\x02\x01\x01\x12\x03\x0c),\n\
    \x10\n\t\x04\0\x03\0\x03\0\x02\x01\x03\x12\x03\x0c/0\n\x0f\n\x08\x04\0\
    \x03\0\x03\0\x02\x02\x12\x03\r\x183\n\x10\n\t\x04\0\x03\0\x03\0\x02\x02\
    \x04\x12\x03\r\x18\x20\n\x10\n\t\x04\0\x03\0\x03\0\x02\x02\x05\x12\x03\r\
    !'\n\x10\n\t\x04\0\x03\0\x03\0\x02\x02\x01\x12\x03\r(.\n\x10\n\t\x04\0\
    \x03\0\x03\0\x02\x02\x03\x12\x03\r12\n\x0f\n\x08\x04\0\x03\0\x03\0\x02\
    \x03\x12\x03\x0e\x188\n\x10\n\t\x04\0\x03\0\x03\0\x02\x03\x04\x12\x03\
    \x0e\x18\x20\n\x10\n\t\x04\0\x03\0\x03\0\x02\x03\x05\x12\x03\x0e!'\n\x10\
    \n\t\x04\0\x03\0\x03\0\x02\x03\x01\x12\x03\x0e(3\n\x10\n\t\x04\0\x03\0\
    \x03\0\x02\x03\x03\x12\x03\x0e67\n\x0f\n\x08\x04\0\x03\0\x03\0\x02\x04\
    \x12\x03\x0f\x18:\n\x10\n\t\x04\0\x03\0\x03\0\x02\x04\x04\x12\x03\x0f\
    \x18\x20\n\x10\n\t\x04\0\x03\0\x03\0\x02\x04\x05\x12\x03\x0f!'\n\x10\n\t\
    \x04\0\x03\0\x03\0\x02\x04\x01\x12\x03\x0f(5\n\x10\n\t\x04\0\x03\0\x03\0\
    \x02\x04\x03\x12\x03\x0f89\n\r\n\x06\x04\0\x03\0\x02\0\x12\x03\x12\x10-\
    \n\x0e\n\x07\x04\0\x03\0\x02\0\x04\x12\x03\x12\x10\x18\n\x0e\n\x07\x04\0\
    \x03\0\x02\0\x05\x12\x03\x12\x19\x1f\n\x0e\n\x07\x04\0\x03\0\x02\0\x01\
    \x12\x03\x12\x20(\n\x0e\n\x07\x04\0\x03\0\x02\0\x03\x12\x03\x12+,\n\r\n\
    \x06\x04\0\x03\0\x02\x01\x12\x03\x13\x10)\n\x0e\n\x07\x04\0\x03\0\x02\
    \x01\x04\x12\x03\x13\x10\x18\n\x0e\n\x07\x04\0\x03\0\x02\x01\x05\x12\x03\
    \x13\x19\x1f\n\x0e\n\x07\x04\0\x03\0\x02\x01\x01\x12\x03\x13\x20$\n\x0e\
    \n\x07\x04\0\x03\0\x02\x01\x03\x12\x03\x13'(\n\r\n\x06\x04\0\x03\0\x02\
    \x02\x12\x03\x14\x10*\n\x0e\n\x07\x04\0\x03\0\x02\x02\x04\x12\x03\x14\
    \x10\x18\n\x0e\n\x07\x04\0\x03\0\x02\x02\x05\x12\x03\x14\x19\x1f\n\x0e\n\
    \x07\x04\0\x03\0\x02\x02\x01\x12\x03\x14\x20%\n\x0e\n\x07\x04\0\x03\0\
    \x02\x02\x03\x12\x03\x14()\n\r\n\x06\x04\0\x03\0\x02\x03\x12\x03\x15\x10\
    0\n\x0e\n\x07\x04\0\x03\0\x02\x03\x04\x12\x03\x15\x10\x18\n\x0e\n\x07\
    \x04\0\x03\0\x02\x03\x05\x12\x03\x15\x19\x1e\n\x0e\n\x07\x04\0\x03\0\x02\
    \x03\x01\x12\x03\x15\x1f+\n\x0e\n\x07\x04\0\x03\0\x02\x03\x03\x12\x03\
    \x15./\n\r\n\x06\x04\0\x03\0\x02\x04\x12\x03\x16\x10/\n\x0e\n\x07\x04\0\
    \x03\0\x02\x04\x04\x12\x03\x16\x10\x18\n\x0e\n\x07\x04\0\x03\0\x02\x04\
    \x05\x12\x03\x16\x19\x1e\n\x0e\n\x07\x04\0\x03\0\x02\x04\x01\x12\x03\x16\
    \x1f*\n\x0e\n\x07\x04\0\x03\0\x02\x04\x03\x12\x03\x16-.\n\r\n\x06\x04\0\
    \x03\0\x02\x05\x12\x03\x17\x10R\n\x0e\n\x07\x04\0\x03\0\x02\x05\x04\x12\
    \x03\x17\x10\x18\n\x0e\n\x07\x04\0\x03\0\x02\x05\x06\x12\x03\x17\x19F\n\
    \x0e\n\x07\x04\0\x03\0\x02\x05\x01\x12\x03\x17GM\n\x0e\n\x07\x04\0\x03\0\
    \x02\x05\x03\x12\x03\x17PQ\n\r\n\x06\x04\0\x03\0\x02\x06\x12\x03\x18\x10\
    /\n\x0e\n\x07\x04\0\x03\0\x02\x06\x04\x12\x03\x18\x10\x18\n\x0e\n\x07\
    \x04\0\x03\0\x02\x06\x05\x12\x03\x18\x19\x1f\n\x0e\n\x07\x04\0\x03\0\x02\
    \x06\x01\x12\x03\x18\x20*\n\x0e\n\x07\x04\0\x03\0\x02\x06\x03\x12\x03\
    \x18-.\n\x0b\n\x04\x04\0\x02\0\x12\x03\x1b\x08B\n\x0c\n\x05\x04\0\x02\0\
    \x04\x12\x03\x1b\x08\x10\n\x0c\n\x05\x04\0\x02\0\x06\x12\x03\x1b\x114\n\
    \x0c\n\x05\x04\0\x02\0\x01\x12\x03\x1b5=\n\x0c\n\x05\x04\0\x02\0\x03\x12\
    \x03\x1b@A\n\n\n\x02\x04\x01\x12\x04\x1e\0(\x01\n\n\n\x03\x04\x01\x01\
    \x12\x03\x1e\x08\x1f\n\x0b\n\x04\x04\x01\x02\0\x12\x03\x1f\x08%\n\x0c\n\
    \x05\x04\x01\x02\0\x04\x12\x03\x1f\x08\x10\n\x0c\n\x05\x04\x01\x02\0\x05\
    \x12\x03\x1f\x11\x17\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\x1f\x18\x20\n\
    \x0c\n\x05\x04\x01\x02\0\x03\x12\x03\x1f#$\n\x0b\n\x04\x04\x01\x02\x01\
    \x12\x03\x20\x08)\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x03\x20\x08\x10\n\
    \x0c\n\x05\x04\x01\x02\x01\x05\x12\x03\x20\x11\x17\n\x0c\n\x05\x04\x01\
    \x02\x01\x01\x12\x03\x20\x18$\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03\
    \x20'(\n\x0b\n\x04\x04\x01\x02\x02\x12\x03!\x08*\n\x0c\n\x05\x04\x01\x02\
    \x02\x04\x12\x03!\x08\x10\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03!\x11\
    \x17\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\x03!\x18%\n\x0c\n\x05\x04\x01\
    \x02\x02\x03\x12\x03!()\n\x0b\n\x04\x04\x01\x02\x03\x12\x03\"\x08.\n\x0c\
    \n\x05\x04\x01\x02\x03\x04\x12\x03\"\x08\x10\n\x0c\n\x05\x04\x01\x02\x03\
    \x05\x12\x03\"\x11\x15\n\x0c\n\x05\x04\x01\x02\x03\x01\x12\x03\"\x16)\n\
    \x0c\n\x05\x04\x01\x02\x03\x03\x12\x03\",-\n\x0b\n\x04\x04\x01\x02\x04\
    \x12\x03#\x08-\n\x0c\n\x05\x04\x01\x02\x04\x04\x12\x03#\x08\x10\n\x0c\n\
    \x05\x04\x01\x02\x04\x05\x12\x03#\x11\x17\n\x0c\n\x05\x04\x01\x02\x04\
    \x01\x12\x03#\x18(\n\x0c\n\x05\x04\x01\x02\x04\x03\x12\x03#+,\n\x0b\n\
    \x04\x04\x01\x02\x05\x12\x03$\x08/\n\x0c\n\x05\x04\x01\x02\x05\x04\x12\
    \x03$\x08\x10\n\x0c\n\x05\x04\x01\x02\x05\x05\x12\x03$\x11\x17\n\x0c\n\
    \x05\x04\x01\x02\x05\x01\x12\x03$\x18*\n\x0c\n\x05\x04\x01\x02\x05\x03\
    \x12\x03$-.\n\x0b\n\x04\x04\x01\x02\x06\x12\x03%\x08*\n\x0c\n\x05\x04\
    \x01\x02\x06\x04\x12\x03%\x08\x10\n\x0c\n\x05\x04\x01\x02\x06\x05\x12\
    \x03%\x11\x17\n\x0c\n\x05\x04\x01\x02\x06\x01\x12\x03%\x18%\n\x0c\n\x05\
    \x04\x01\x02\x06\x03\x12\x03%()\n\x0b\n\x04\x04\x01\x02\x07\x12\x03&\x08\
    *\n\x0c\n\x05\x04\x01\x02\x07\x04\x12\x03&\x08\x10\n\x0c\n\x05\x04\x01\
    \x02\x07\x05\x12\x03&\x11\x17\n\x0c\n\x05\x04\x01\x02\x07\x01\x12\x03&\
    \x18%\n\x0c\n\x05\x04\x01\x02\x07\x03\x12\x03&()\n\x0b\n\x04\x04\x01\x02\
    \x08\x12\x03'\x08&\n\x0c\n\x05\x04\x01\x02\x08\x04\x12\x03'\x08\x10\n\
    \x0c\n\x05\x04\x01\x02\x08\x05\x12\x03'\x11\x17\n\x0c\n\x05\x04\x01\x02\
    \x08\x01\x12\x03'\x18!\n\x0c\n\x05\x04\x01\x02\x08\x03\x12\x03'$%\n\n\n\
    \x02\x04\x02\x12\x04*\0,\x01\n\n\n\x03\x04\x02\x01\x12\x03*\x08\x20\n\
    \x0b\n\x04\x04\x02\x02\0\x12\x03+\x08%\n\x0c\n\x05\x04\x02\x02\0\x04\x12\
    \x03+\x08\x10\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03+\x11\x16\n\x0c\n\x05\
    \x04\x02\x02\0\x01\x12\x03+\x17\x20\n\x0c\n\x05\x04\x02\x02\0\x03\x12\
    \x03+#$\n\n\n\x02\x04\x03\x12\x04.\0=\x01\n\n\n\x03\x04\x03\x01\x12\x03.\
    \x08\x1a\n\x0c\n\x04\x04\x03\x03\0\x12\x04/\x086\t\n\x0c\n\x05\x04\x03\
    \x03\0\x01\x12\x03/\x10\x1a\n\r\n\x06\x04\x03\x03\0\x02\0\x12\x030\x10.\
    \n\x0e\n\x07\x04\x03\x03\0\x02\0\x04\x12\x030\x10\x18\n\x0e\n\x07\x04\
    \x03\x03\0\x02\0\x05\x12\x030\x19\x1e\n\x0e\n\x07\x04\x03\x03\0\x02\0\
    \x01\x12\x030\x1f)\n\x0e\n\x07\x04\x03\x03\0\x02\0\x03\x12\x030,-\n\r\n\
    \x06\x04\x03\x03\0\x02\x01\x12\x031\x10.\n\x0e\n\x07\x04\x03\x03\0\x02\
    \x01\x04\x12\x031\x10\x18\n\x0e\n\x07\x04\x03\x03\0\x02\x01\x05\x12\x031\
    \x19\x1e\n\x0e\n\x07\x04\x03\x03\0\x02\x01\x01\x12\x031\x1f)\n\x0e\n\x07\
    \x04\x03\x03\0\x02\x01\x03\x12\x031,-\n\r\n\x06\x04\x03\x03\0\x02\x02\
    \x12\x032\x102\n\x0e\n\x07\x04\x03\x03\0\x02\x02\x04\x12\x032\x10\x18\n\
    \x0e\n\x07\x04\x03\x03\0\x02\x02\x05\x12\x032\x19\x1f\n\x0e\n\x07\x04\
    \x03\x03\0\x02\x02\x01\x12\x032\x20-\n\x0e\n\x07\x04\x03\x03\0\x02\x02\
    \x03\x12\x03201\n\r\n\x06\x04\x03\x03\0\x02\x03\x12\x033\x101\n\x0e\n\
    \x07\x04\x03\x03\0\x02\x03\x04\x12\x033\x10\x18\n\x0e\n\x07\x04\x03\x03\
    \0\x02\x03\x05\x12\x033\x19\x1f\n\x0e\n\x07\x04\x03\x03\0\x02\x03\x01\
    \x12\x033\x20,\n\x0e\n\x07\x04\x03\x03\0\x02\x03\x03\x12\x033/0\n\r\n\
    \x06\x04\x03\x03\0\x02\x04\x12\x034\x10)\n\x0e\n\x07\x04\x03\x03\0\x02\
    \x04\x04\x12\x034\x10\x18\n\x0e\n\x07\x04\x03\x03\0\x02\x04\x05\x12\x034\
    \x19\x1e\n\x0e\n\x07\x04\x03\x03\0\x02\x04\x01\x12\x034\x1f$\n\x0e\n\x07\
    \x04\x03\x03\0\x02\x04\x03\x12\x034'(\n\r\n\x06\x04\x03\x03\0\x02\x05\
    \x12\x035\x10/\n\x0e\n\x07\x04\x03\x03\0\x02\x05\x04\x12\x035\x10\x18\n\
    \x0e\n\x07\x04\x03\x03\0\x02\x05\x05\x12\x035\x19\x1f\n\x0e\n\x07\x04\
    \x03\x03\0\x02\x05\x01\x12\x035\x20*\n\x0e\n\x07\x04\x03\x03\0\x02\x05\
    \x03\x12\x035-.\n\x0b\n\x04\x04\x03\x02\0\x12\x038\x08%\n\x0c\n\x05\x04\
    \x03\x02\0\x04\x12\x038\x08\x10\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x038\
    \x11\x17\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x038\x18\x20\n\x0c\n\x05\x04\
    \x03\x02\0\x03\x12\x038#$\n\x0b\n\x04\x04\x03\x02\x01\x12\x039\x08/\n\
    \x0c\n\x05\x04\x03\x02\x01\x04\x12\x039\x08\x10\n\x0c\n\x05\x04\x03\x02\
    \x01\x05\x12\x039\x11\x17\n\x0c\n\x05\x04\x03\x02\x01\x01\x12\x039\x18*\
    \n\x0c\n\x05\x04\x03\x02\x01\x03\x12\x039-.\n\x0b\n\x04\x04\x03\x02\x02\
    \x12\x03:\x08/\n\x0c\n\x05\x04\x03\x02\x02\x04\x12\x03:\x08\x10\n\x0c\n\
    \x05\x04\x03\x02\x02\x05\x12\x03:\x11\x17\n\x0c\n\x05\x04\x03\x02\x02\
    \x01\x12\x03:\x18*\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03:-.\n\x0b\n\
    \x04\x04\x03\x02\x03\x12\x03;\x08@\n\x0c\n\x05\x04\x03\x02\x03\x04\x12\
    \x03;\x08\x10\n\x0c\n\x05\x04\x03\x02\x03\x06\x12\x03;\x11/\n\x0c\n\x05\
    \x04\x03\x02\x03\x01\x12\x03;0;\n\x0c\n\x05\x04\x03\x02\x03\x03\x12\x03;\
    >?\n\x0c\n\x04\x04\x03\x02\x04\x12\x04<\x08\x80\x01\n\x0c\n\x05\x04\x03\
    \x02\x04\x04\x12\x03<\x08\x10\n\x0c\n\x05\x04\x03\x02\x04\x06\x12\x03<\
    \x110\n\x0c\n\x05\x04\x03\x02\x04\x01\x12\x03<1D\n\x0c\n\x05\x04\x03\x02\
    \x04\x03\x12\x03<GH\n\x0c\n\x05\x04\x03\x02\x04\x08\x12\x03<I\x7f\n\x0c\
    \n\x05\x04\x03\x02\x04\x07\x12\x03<T~\
";

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

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

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