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

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

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

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

//! Generated file from `content_manifest.proto`
// Generated for lite runtime

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

// @@protoc_insertion_point(message:ContentManifestPayload)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ContentManifestPayload {
    // message fields
    // @@protoc_insertion_point(field:ContentManifestPayload.mappings)
    pub mappings: ::std::vec::Vec<content_manifest_payload::FileMapping>,
    // special fields
    // @@protoc_insertion_point(special_field:ContentManifestPayload.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

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

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

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

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

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

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

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

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

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

/// Nested message and enums of message `ContentManifestPayload`
pub mod content_manifest_payload {
    // @@protoc_insertion_point(message:ContentManifestPayload.FileMapping)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct FileMapping {
        // message fields
        // @@protoc_insertion_point(field:ContentManifestPayload.FileMapping.filename)
        pub filename: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:ContentManifestPayload.FileMapping.size)
        pub size: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:ContentManifestPayload.FileMapping.flags)
        pub flags: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:ContentManifestPayload.FileMapping.sha_filename)
        pub sha_filename: ::std::option::Option<::std::vec::Vec<u8>>,
        // @@protoc_insertion_point(field:ContentManifestPayload.FileMapping.sha_content)
        pub sha_content: ::std::option::Option<::std::vec::Vec<u8>>,
        // @@protoc_insertion_point(field:ContentManifestPayload.FileMapping.chunks)
        pub chunks: ::std::vec::Vec<file_mapping::ChunkData>,
        // @@protoc_insertion_point(field:ContentManifestPayload.FileMapping.linktarget)
        pub linktarget: ::std::option::Option<::std::string::String>,
        // special fields
        // @@protoc_insertion_point(special_field:ContentManifestPayload.FileMapping.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional string filename = 1;

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

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

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

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

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

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

        // optional uint64 size = 2;

        pub fn 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 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 sha_filename(&self) -> &[u8] {
            match self.sha_filename.as_ref() {
                Some(v) => v,
                None => &[],
            }
        }

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

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

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

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

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

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

        // optional string linktarget = 7;

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

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

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

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

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

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.filename = ::std::option::Option::Some(is.read_string()?);
                    },
                    16 => {
                        self.size = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    24 => {
                        self.flags = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    34 => {
                        self.sha_filename = ::std::option::Option::Some(is.read_bytes()?);
                    },
                    42 => {
                        self.sha_content = ::std::option::Option::Some(is.read_bytes()?);
                    },
                    50 => {
                        self.chunks.push(is.read_message()?);
                    },
                    58 => {
                        self.linktarget = ::std::option::Option::Some(is.read_string()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.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(v) = self.sha_filename.as_ref() {
                os.write_bytes(4, v)?;
            }
            if let Some(v) = self.sha_content.as_ref() {
                os.write_bytes(5, v)?;
            }
            for v in &self.chunks {
                ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
            };
            if let Some(v) = self.linktarget.as_ref() {
                os.write_string(7, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

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

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

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

        fn clear(&mut self) {
            self.filename = ::std::option::Option::None;
            self.size = ::std::option::Option::None;
            self.flags = ::std::option::Option::None;
            self.sha_filename = ::std::option::Option::None;
            self.sha_content = ::std::option::Option::None;
            self.chunks.clear();
            self.linktarget = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static FileMapping {
            static instance: FileMapping = FileMapping {
                filename: ::std::option::Option::None,
                size: ::std::option::Option::None,
                flags: ::std::option::Option::None,
                sha_filename: ::std::option::Option::None,
                sha_content: ::std::option::Option::None,
                chunks: ::std::vec::Vec::new(),
                linktarget: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `FileMapping`
    pub mod file_mapping {
        // @@protoc_insertion_point(message:ContentManifestPayload.FileMapping.ChunkData)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct ChunkData {
            // message fields
            // @@protoc_insertion_point(field:ContentManifestPayload.FileMapping.ChunkData.sha)
            pub sha: ::std::option::Option<::std::vec::Vec<u8>>,
            // @@protoc_insertion_point(field:ContentManifestPayload.FileMapping.ChunkData.crc)
            pub crc: ::std::option::Option<u32>,
            // @@protoc_insertion_point(field:ContentManifestPayload.FileMapping.ChunkData.offset)
            pub offset: ::std::option::Option<u64>,
            // @@protoc_insertion_point(field:ContentManifestPayload.FileMapping.ChunkData.cb_original)
            pub cb_original: ::std::option::Option<u32>,
            // @@protoc_insertion_point(field:ContentManifestPayload.FileMapping.ChunkData.cb_compressed)
            pub cb_compressed: ::std::option::Option<u32>,
            // special fields
            // @@protoc_insertion_point(special_field:ContentManifestPayload.FileMapping.ChunkData.special_fields)
            pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
        }

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

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

            // optional bytes sha = 1;

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

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

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

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

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

            fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
                while let Some(tag) = is.read_raw_tag_or_eof()? {
                    match tag {
                        10 => {
                            self.sha = ::std::option::Option::Some(is.read_bytes()?);
                        },
                        21 => {
                            self.crc = ::std::option::Option::Some(is.read_fixed32()?);
                        },
                        24 => {
                            self.offset = ::std::option::Option::Some(is.read_uint64()?);
                        },
                        32 => {
                            self.cb_original = ::std::option::Option::Some(is.read_uint32()?);
                        },
                        40 => {
                            self.cb_compressed = ::std::option::Option::Some(is.read_uint32()?);
                        },
                        tag => {
                            ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                        },
                    };
                }
                ::std::result::Result::Ok(())
            }

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

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

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

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

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

            fn clear(&mut self) {
                self.sha = ::std::option::Option::None;
                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.special_fields.clear();
            }

            fn default_instance() -> &'static ChunkData {
                static instance: ChunkData = ChunkData {
                    sha: ::std::option::Option::None,
                    crc: ::std::option::Option::None,
                    offset: ::std::option::Option::None,
                    cb_original: ::std::option::Option::None,
                    cb_compressed: ::std::option::Option::None,
                    special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }
    }
}

// @@protoc_insertion_point(message:ContentManifestMetadata)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ContentManifestMetadata {
    // message fields
    // @@protoc_insertion_point(field:ContentManifestMetadata.depot_id)
    pub depot_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:ContentManifestMetadata.gid_manifest)
    pub gid_manifest: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:ContentManifestMetadata.creation_time)
    pub creation_time: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:ContentManifestMetadata.filenames_encrypted)
    pub filenames_encrypted: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:ContentManifestMetadata.cb_disk_original)
    pub cb_disk_original: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:ContentManifestMetadata.cb_disk_compressed)
    pub cb_disk_compressed: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:ContentManifestMetadata.unique_chunks)
    pub unique_chunks: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:ContentManifestMetadata.crc_encrypted)
    pub crc_encrypted: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:ContentManifestMetadata.crc_clear)
    pub crc_clear: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:ContentManifestMetadata.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 depot_id = 1;

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.depot_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.gid_manifest = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.creation_time = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.filenames_encrypted = ::std::option::Option::Some(is.read_bool()?);
                },
                40 => {
                    self.cb_disk_original = ::std::option::Option::Some(is.read_uint64()?);
                },
                48 => {
                    self.cb_disk_compressed = ::std::option::Option::Some(is.read_uint64()?);
                },
                56 => {
                    self.unique_chunks = ::std::option::Option::Some(is.read_uint32()?);
                },
                64 => {
                    self.crc_encrypted = ::std::option::Option::Some(is.read_uint32()?);
                },
                72 => {
                    self.crc_clear = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    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.special_fields.clear();
    }

    fn default_instance() -> &'static ContentManifestMetadata {
        static instance: ContentManifestMetadata = ContentManifestMetadata {
            depot_id: ::std::option::Option::None,
            gid_manifest: ::std::option::Option::None,
            creation_time: ::std::option::Option::None,
            filenames_encrypted: ::std::option::Option::None,
            cb_disk_original: ::std::option::Option::None,
            cb_disk_compressed: ::std::option::Option::None,
            unique_chunks: ::std::option::Option::None,
            crc_encrypted: ::std::option::Option::None,
            crc_clear: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional bytes signature = 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// @@protoc_insertion_point(message:ContentDeltaChunks)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ContentDeltaChunks {
    // message fields
    // @@protoc_insertion_point(field:ContentDeltaChunks.depot_id)
    pub depot_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:ContentDeltaChunks.manifest_id_source)
    pub manifest_id_source: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:ContentDeltaChunks.manifest_id_target)
    pub manifest_id_target: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:ContentDeltaChunks.deltaChunks)
    pub deltaChunks: ::std::vec::Vec<content_delta_chunks::DeltaChunk>,
    // @@protoc_insertion_point(field:ContentDeltaChunks.chunk_data_location)
    pub chunk_data_location: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<EContentDeltaChunkDataLocation>>,
    // special fields
    // @@protoc_insertion_point(special_field:ContentDeltaChunks.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint32 depot_id = 1;

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

    // optional .EContentDeltaChunkDataLocation chunk_data_location = 5;

    pub fn chunk_data_location(&self) -> EContentDeltaChunkDataLocation {
        match self.chunk_data_location {
            Some(e) => e.enum_value_or(EContentDeltaChunkDataLocation::k_EContentDeltaChunkDataLocationInProtobuf),
            None => 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(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
    }
}

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.depot_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.manifest_id_source = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.manifest_id_target = ::std::option::Option::Some(is.read_uint64()?);
                },
                34 => {
                    self.deltaChunks.push(is.read_message()?);
                },
                40 => {
                    self.chunk_data_location = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.depot_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.manifest_id_source {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.manifest_id_target {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
        }
        for value in &self.deltaChunks {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.chunk_data_location {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v.value());
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.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 {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        if let Some(v) = self.chunk_data_location {
            os.write_enum(5, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    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.special_fields.clear();
    }

    fn default_instance() -> &'static ContentDeltaChunks {
        static instance: ContentDeltaChunks = ContentDeltaChunks {
            depot_id: ::std::option::Option::None,
            manifest_id_source: ::std::option::Option::None,
            manifest_id_target: ::std::option::Option::None,
            deltaChunks: ::std::vec::Vec::new(),
            chunk_data_location: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `ContentDeltaChunks`
pub mod content_delta_chunks {
    // @@protoc_insertion_point(message:ContentDeltaChunks.DeltaChunk)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct DeltaChunk {
        // message fields
        // @@protoc_insertion_point(field:ContentDeltaChunks.DeltaChunk.sha_source)
        pub sha_source: ::std::option::Option<::std::vec::Vec<u8>>,
        // @@protoc_insertion_point(field:ContentDeltaChunks.DeltaChunk.sha_target)
        pub sha_target: ::std::option::Option<::std::vec::Vec<u8>>,
        // @@protoc_insertion_point(field:ContentDeltaChunks.DeltaChunk.size_original)
        pub size_original: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:ContentDeltaChunks.DeltaChunk.patch_method)
        pub patch_method: ::std::option::Option<u32>,
        // @@protoc_insertion_point(field:ContentDeltaChunks.DeltaChunk.chunk)
        pub chunk: ::std::option::Option<::std::vec::Vec<u8>>,
        // @@protoc_insertion_point(field:ContentDeltaChunks.DeltaChunk.size_delta)
        pub size_delta: ::std::option::Option<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:ContentDeltaChunks.DeltaChunk.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional bytes sha_source = 1;

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

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

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

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

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

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

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

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

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

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

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

        fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.sha_source = ::std::option::Option::Some(is.read_bytes()?);
                    },
                    18 => {
                        self.sha_target = ::std::option::Option::Some(is.read_bytes()?);
                    },
                    24 => {
                        self.size_original = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    32 => {
                        self.patch_method = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    42 => {
                        self.chunk = ::std::option::Option::Some(is.read_bytes()?);
                    },
                    48 => {
                        self.size_delta = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

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

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

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

        fn clear(&mut self) {
            self.sha_source = ::std::option::Option::None;
            self.sha_target = ::std::option::Option::None;
            self.size_original = ::std::option::Option::None;
            self.patch_method = ::std::option::Option::None;
            self.chunk = ::std::option::Option::None;
            self.size_delta = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static DeltaChunk {
            static instance: DeltaChunk = DeltaChunk {
                sha_source: ::std::option::Option::None,
                sha_target: ::std::option::Option::None,
                size_original: ::std::option::Option::None,
                patch_method: ::std::option::Option::None,
                chunk: ::std::option::Option::None,
                size_delta: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:EContentDeltaChunkDataLocation)
pub enum EContentDeltaChunkDataLocation {
    // @@protoc_insertion_point(enum_value:EContentDeltaChunkDataLocation.k_EContentDeltaChunkDataLocationInProtobuf)
    k_EContentDeltaChunkDataLocationInProtobuf = 0,
    // @@protoc_insertion_point(enum_value:EContentDeltaChunkDataLocation.k_EContentDeltaChunkDataLocationAfterProtobuf)
    k_EContentDeltaChunkDataLocationAfterProtobuf = 1,
}

impl ::steam_vent_proto_common::protobuf::Enum for EContentDeltaChunkDataLocation {
    const NAME: &'static str = "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 from_str(str: &str) -> ::std::option::Option<EContentDeltaChunkDataLocation> {
        match str {
            "k_EContentDeltaChunkDataLocationInProtobuf" => ::std::option::Option::Some(EContentDeltaChunkDataLocation::k_EContentDeltaChunkDataLocationInProtobuf),
            "k_EContentDeltaChunkDataLocationAfterProtobuf" => ::std::option::Option::Some(EContentDeltaChunkDataLocation::k_EContentDeltaChunkDataLocationAfterProtobuf),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [EContentDeltaChunkDataLocation] = &[
        EContentDeltaChunkDataLocation::k_EContentDeltaChunkDataLocationInProtobuf,
        EContentDeltaChunkDataLocation::k_EContentDeltaChunkDataLocationAfterProtobuf,
    ];
}

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



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

impl ::steam_vent_proto_common::RpcMessage for ContentManifestPayload {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for ContentManifestMetadata {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for ContentManifestSignature {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
impl ::steam_vent_proto_common::RpcMessage for ContentDeltaChunks {
    fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
        <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
    }
    fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
        use ::steam_vent_proto_common::protobuf::Message;
        self.write_to_writer(writer)
    }
    fn encode_size(&self) -> usize {
        use ::steam_vent_proto_common::protobuf::Message;
        self.compute_size() as usize
    }
}
