// 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 `webuimessages_gamerecordingfiles.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:CGameRecordingFile)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CGameRecordingFile {
    // message fields
    // @@protoc_insertion_point(field:CGameRecordingFile.timelines)
    pub timelines: ::std::vec::Vec<CGameRecordingTimelineMetadata>,
    // @@protoc_insertion_point(field:CGameRecordingFile.postgame_events)
    pub postgame_events: ::std::vec::Vec<CGameRecordingPostGameSummary>,
    // @@protoc_insertion_point(field:CGameRecordingFile.temporary_clips)
    pub temporary_clips: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:CGameRecordingFile.tags)
    pub tags: ::std::vec::Vec<CGameRecordingTag>,
    // special fields
    // @@protoc_insertion_point(special_field:CGameRecordingFile.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

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

    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.timelines.push(is.read_message()?);
                },
                18 => {
                    self.postgame_events.push(is.read_message()?);
                },
                26 => {
                    self.temporary_clips.push(is.read_string()?);
                },
                34 => {
                    self.tags.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.timelines {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.postgame_events {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.temporary_clips {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &value);
        };
        for value in &self.tags {
            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.timelines {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        for v in &self.postgame_events {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        for v in &self.temporary_clips {
            os.write_string(3, &v)?;
        };
        for v in &self.tags {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(4, 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() -> CGameRecordingFile {
        CGameRecordingFile::new()
    }

    fn clear(&mut self) {
        self.timelines.clear();
        self.postgame_events.clear();
        self.temporary_clips.clear();
        self.tags.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CGameRecordingFile {
        static instance: CGameRecordingFile = CGameRecordingFile {
            timelines: ::std::vec::Vec::new(),
            postgame_events: ::std::vec::Vec::new(),
            temporary_clips: ::std::vec::Vec::new(),
            tags: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CGameRecordingClipFile)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CGameRecordingClipFile {
    // message fields
    // @@protoc_insertion_point(field:CGameRecordingClipFile.timelines)
    pub timelines: ::std::vec::Vec<CGameRecordingTimelineMetadata>,
    // @@protoc_insertion_point(field:CGameRecordingClipFile.first_timeline_start_offset_ms)
    pub first_timeline_start_offset_ms: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CGameRecordingClipFile.date_recorded)
    pub date_recorded: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CGameRecordingClipFile.game_id)
    pub game_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CGameRecordingClipFile.published_file_id)
    pub published_file_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CGameRecordingClipFile.size_in_bytes)
    pub size_in_bytes: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CGameRecordingClipFile.name)
    pub name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CGameRecordingClipFile.temporary)
    pub temporary: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:CGameRecordingClipFile.original_device)
    pub original_device: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CGameRecordingClipFile.original_gaming_device_type)
    pub original_gaming_device_type: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CGameRecordingClipFile.date_downloaded)
    pub date_downloaded: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CGameRecordingClipFile.thumbnail_width)
    pub thumbnail_width: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CGameRecordingClipFile.thumbnail_height)
    pub thumbnail_height: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CGameRecordingClipFile.tags)
    pub tags: ::std::vec::Vec<CGameRecordingTag>,
    // @@protoc_insertion_point(field:CGameRecordingClipFile.phases)
    pub phases: ::std::vec::Vec<CGameRecordingPhase>,
    // special fields
    // @@protoc_insertion_point(special_field:CGameRecordingClipFile.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint64 first_timeline_start_offset_ms = 2;

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

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

    pub fn has_first_timeline_start_offset_ms(&self) -> bool {
        self.first_timeline_start_offset_ms.is_some()
    }

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

    // optional uint32 date_recorded = 3;

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

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

    pub fn has_date_recorded(&self) -> bool {
        self.date_recorded.is_some()
    }

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

    // optional uint64 game_id = 4;

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

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

    pub fn has_game_id(&self) -> bool {
        self.game_id.is_some()
    }

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

    // optional fixed64 published_file_id = 5;

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

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

    pub fn has_published_file_id(&self) -> bool {
        self.published_file_id.is_some()
    }

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

    // optional uint64 size_in_bytes = 6;

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

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

    pub fn has_size_in_bytes(&self) -> bool {
        self.size_in_bytes.is_some()
    }

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

    // optional string name = 7;

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

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

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

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

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

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

    // optional bool temporary = 8;

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

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

    pub fn has_temporary(&self) -> bool {
        self.temporary.is_some()
    }

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

    // optional string original_device = 9;

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

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

    pub fn has_original_device(&self) -> bool {
        self.original_device.is_some()
    }

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

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

    // optional uint32 original_gaming_device_type = 10;

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

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

    pub fn has_original_gaming_device_type(&self) -> bool {
        self.original_gaming_device_type.is_some()
    }

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

    // optional uint32 date_downloaded = 11;

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

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

    pub fn has_date_downloaded(&self) -> bool {
        self.date_downloaded.is_some()
    }

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

    // optional uint32 thumbnail_width = 12;

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

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

    pub fn has_thumbnail_width(&self) -> bool {
        self.thumbnail_width.is_some()
    }

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

    // optional uint32 thumbnail_height = 13;

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

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

    pub fn has_thumbnail_height(&self) -> bool {
        self.thumbnail_height.is_some()
    }

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

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

    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.timelines.push(is.read_message()?);
                },
                16 => {
                    self.first_timeline_start_offset_ms = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.date_recorded = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.game_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                41 => {
                    self.published_file_id = ::std::option::Option::Some(is.read_fixed64()?);
                },
                48 => {
                    self.size_in_bytes = ::std::option::Option::Some(is.read_uint64()?);
                },
                58 => {
                    self.name = ::std::option::Option::Some(is.read_string()?);
                },
                64 => {
                    self.temporary = ::std::option::Option::Some(is.read_bool()?);
                },
                74 => {
                    self.original_device = ::std::option::Option::Some(is.read_string()?);
                },
                80 => {
                    self.original_gaming_device_type = ::std::option::Option::Some(is.read_uint32()?);
                },
                88 => {
                    self.date_downloaded = ::std::option::Option::Some(is.read_uint32()?);
                },
                96 => {
                    self.thumbnail_width = ::std::option::Option::Some(is.read_uint32()?);
                },
                104 => {
                    self.thumbnail_height = ::std::option::Option::Some(is.read_uint32()?);
                },
                114 => {
                    self.tags.push(is.read_message()?);
                },
                122 => {
                    self.phases.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.timelines {
            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.first_timeline_start_offset_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.date_recorded {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.game_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(4, v);
        }
        if let Some(v) = self.published_file_id {
            my_size += 1 + 8;
        }
        if let Some(v) = self.size_in_bytes {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(6, v);
        }
        if let Some(v) = self.name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
        }
        if let Some(v) = self.temporary {
            my_size += 1 + 1;
        }
        if let Some(v) = self.original_device.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &v);
        }
        if let Some(v) = self.original_gaming_device_type {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(10, v);
        }
        if let Some(v) = self.date_downloaded {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(11, v);
        }
        if let Some(v) = self.thumbnail_width {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(12, v);
        }
        if let Some(v) = self.thumbnail_height {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(13, v);
        }
        for value in &self.tags {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.phases {
            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.timelines {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        if let Some(v) = self.first_timeline_start_offset_ms {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.date_recorded {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.game_id {
            os.write_uint64(4, v)?;
        }
        if let Some(v) = self.published_file_id {
            os.write_fixed64(5, v)?;
        }
        if let Some(v) = self.size_in_bytes {
            os.write_uint64(6, v)?;
        }
        if let Some(v) = self.name.as_ref() {
            os.write_string(7, v)?;
        }
        if let Some(v) = self.temporary {
            os.write_bool(8, v)?;
        }
        if let Some(v) = self.original_device.as_ref() {
            os.write_string(9, v)?;
        }
        if let Some(v) = self.original_gaming_device_type {
            os.write_uint32(10, v)?;
        }
        if let Some(v) = self.date_downloaded {
            os.write_uint32(11, v)?;
        }
        if let Some(v) = self.thumbnail_width {
            os.write_uint32(12, v)?;
        }
        if let Some(v) = self.thumbnail_height {
            os.write_uint32(13, v)?;
        }
        for v in &self.tags {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(14, v, os)?;
        };
        for v in &self.phases {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(15, 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() -> CGameRecordingClipFile {
        CGameRecordingClipFile::new()
    }

    fn clear(&mut self) {
        self.timelines.clear();
        self.first_timeline_start_offset_ms = ::std::option::Option::None;
        self.date_recorded = ::std::option::Option::None;
        self.game_id = ::std::option::Option::None;
        self.published_file_id = ::std::option::Option::None;
        self.size_in_bytes = ::std::option::Option::None;
        self.name = ::std::option::Option::None;
        self.temporary = ::std::option::Option::None;
        self.original_device = ::std::option::Option::None;
        self.original_gaming_device_type = ::std::option::Option::None;
        self.date_downloaded = ::std::option::Option::None;
        self.thumbnail_width = ::std::option::Option::None;
        self.thumbnail_height = ::std::option::Option::None;
        self.tags.clear();
        self.phases.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CGameRecordingClipFile {
        static instance: CGameRecordingClipFile = CGameRecordingClipFile {
            timelines: ::std::vec::Vec::new(),
            first_timeline_start_offset_ms: ::std::option::Option::None,
            date_recorded: ::std::option::Option::None,
            game_id: ::std::option::Option::None,
            published_file_id: ::std::option::Option::None,
            size_in_bytes: ::std::option::Option::None,
            name: ::std::option::Option::None,
            temporary: ::std::option::Option::None,
            original_device: ::std::option::Option::None,
            original_gaming_device_type: ::std::option::Option::None,
            date_downloaded: ::std::option::Option::None,
            thumbnail_width: ::std::option::Option::None,
            thumbnail_height: ::std::option::Option::None,
            tags: ::std::vec::Vec::new(),
            phases: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CGameRecordingTimelineMetadata)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CGameRecordingTimelineMetadata {
    // message fields
    // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.timeline_id)
    pub timeline_id: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.game_id)
    pub game_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.date_recorded)
    pub date_recorded: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.duration_ms)
    pub duration_ms: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.recordings)
    pub recordings: ::std::vec::Vec<cgame_recording_timeline_metadata::Recording>,
    // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.phases)
    pub phases: ::std::vec::Vec<CGameRecordingPhase>,
    // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.significant_events)
    pub significant_events: ::std::vec::Vec<CGameRecordingTimelineEvent>,
    // special fields
    // @@protoc_insertion_point(special_field:CGameRecordingTimelineMetadata.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string timeline_id = 1;

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

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

    pub fn has_timeline_id(&self) -> bool {
        self.timeline_id.is_some()
    }

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

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

    // optional uint64 game_id = 2;

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

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

    pub fn has_game_id(&self) -> bool {
        self.game_id.is_some()
    }

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

    // optional uint32 date_recorded = 3;

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

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

    pub fn has_date_recorded(&self) -> bool {
        self.date_recorded.is_some()
    }

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

    // optional uint64 duration_ms = 4;

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

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

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

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

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

    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.timeline_id = ::std::option::Option::Some(is.read_string()?);
                },
                16 => {
                    self.game_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.date_recorded = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.duration_ms = ::std::option::Option::Some(is.read_uint64()?);
                },
                42 => {
                    self.recordings.push(is.read_message()?);
                },
                50 => {
                    self.phases.push(is.read_message()?);
                },
                58 => {
                    self.significant_events.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.timeline_id.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.game_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.date_recorded {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.duration_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(4, v);
        }
        for value in &self.recordings {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.phases {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.significant_events {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.timeline_id.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.game_id {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.date_recorded {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.duration_ms {
            os.write_uint64(4, v)?;
        }
        for v in &self.recordings {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        };
        for v in &self.phases {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        };
        for v in &self.significant_events {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.timeline_id = ::std::option::Option::None;
        self.game_id = ::std::option::Option::None;
        self.date_recorded = ::std::option::Option::None;
        self.duration_ms = ::std::option::Option::None;
        self.recordings.clear();
        self.phases.clear();
        self.significant_events.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CGameRecordingTimelineMetadata {
        static instance: CGameRecordingTimelineMetadata = CGameRecordingTimelineMetadata {
            timeline_id: ::std::option::Option::None,
            game_id: ::std::option::Option::None,
            date_recorded: ::std::option::Option::None,
            duration_ms: ::std::option::Option::None,
            recordings: ::std::vec::Vec::new(),
            phases: ::std::vec::Vec::new(),
            significant_events: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CGameRecordingTimelineMetadata`
pub mod cgame_recording_timeline_metadata {
    // @@protoc_insertion_point(message:CGameRecordingTimelineMetadata.Recording)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Recording {
        // message fields
        // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.Recording.recording_id)
        pub recording_id: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.Recording.start_offset_ms)
        pub start_offset_ms: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.Recording.duration_ms)
        pub duration_ms: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.Recording.recording_type)
        pub recording_type: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<super::super::enums::EGameRecordingType>>,
        // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.Recording.delete_on_cleanup)
        pub delete_on_cleanup: ::std::option::Option<bool>,
        // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.Recording.video_manager_clip_id)
        pub video_manager_clip_id: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.Recording.video_manager_video_id)
        pub video_manager_video_id: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.Recording.cdn_manifest_url)
        pub cdn_manifest_url: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.Recording.file_size)
        pub file_size: ::std::option::Option<u64>,
        // @@protoc_insertion_point(field:CGameRecordingTimelineMetadata.Recording.recording_zero_timeline_offset_ms)
        pub recording_zero_timeline_offset_ms: ::std::option::Option<u64>,
        // special fields
        // @@protoc_insertion_point(special_field:CGameRecordingTimelineMetadata.Recording.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional string recording_id = 1;

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

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

        pub fn has_recording_id(&self) -> bool {
            self.recording_id.is_some()
        }

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

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

        // optional uint64 start_offset_ms = 2;

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

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

        pub fn has_start_offset_ms(&self) -> bool {
            self.start_offset_ms.is_some()
        }

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

        // optional uint64 duration_ms = 3;

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

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

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

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

        // optional .EGameRecordingType recording_type = 4;

        pub fn recording_type(&self) -> super::super::enums::EGameRecordingType {
            match self.recording_type {
                Some(e) => e.enum_value_or(super::super::enums::EGameRecordingType::k_EGameRecordingType_Unknown),
                None => super::super::enums::EGameRecordingType::k_EGameRecordingType_Unknown,
            }
        }

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

        pub fn has_recording_type(&self) -> bool {
            self.recording_type.is_some()
        }

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

        // optional bool delete_on_cleanup = 5;

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

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

        pub fn has_delete_on_cleanup(&self) -> bool {
            self.delete_on_cleanup.is_some()
        }

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

        // optional uint64 video_manager_clip_id = 6;

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

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

        pub fn has_video_manager_clip_id(&self) -> bool {
            self.video_manager_clip_id.is_some()
        }

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

        // optional uint64 video_manager_video_id = 7;

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

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

        pub fn has_video_manager_video_id(&self) -> bool {
            self.video_manager_video_id.is_some()
        }

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

        // optional string cdn_manifest_url = 8;

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

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

        pub fn has_cdn_manifest_url(&self) -> bool {
            self.cdn_manifest_url.is_some()
        }

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

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

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

        // optional uint64 file_size = 9;

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

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

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

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

        // optional uint64 recording_zero_timeline_offset_ms = 10;

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

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

        pub fn has_recording_zero_timeline_offset_ms(&self) -> bool {
            self.recording_zero_timeline_offset_ms.is_some()
        }

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

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

        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.recording_id = ::std::option::Option::Some(is.read_string()?);
                    },
                    16 => {
                        self.start_offset_ms = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    24 => {
                        self.duration_ms = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    32 => {
                        self.recording_type = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                    },
                    40 => {
                        self.delete_on_cleanup = ::std::option::Option::Some(is.read_bool()?);
                    },
                    48 => {
                        self.video_manager_clip_id = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    56 => {
                        self.video_manager_video_id = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    66 => {
                        self.cdn_manifest_url = ::std::option::Option::Some(is.read_string()?);
                    },
                    72 => {
                        self.file_size = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    80 => {
                        self.recording_zero_timeline_offset_ms = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if let Some(v) = self.recording_id.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
            }
            if let Some(v) = self.start_offset_ms {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
            }
            if let Some(v) = self.duration_ms {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(3, v);
            }
            if let Some(v) = self.recording_type {
                my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v.value());
            }
            if let Some(v) = self.delete_on_cleanup {
                my_size += 1 + 1;
            }
            if let Some(v) = self.video_manager_clip_id {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(6, v);
            }
            if let Some(v) = self.video_manager_video_id {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(7, v);
            }
            if let Some(v) = self.cdn_manifest_url.as_ref() {
                my_size += ::steam_vent_proto_common::protobuf::rt::string_size(8, &v);
            }
            if let Some(v) = self.file_size {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(9, v);
            }
            if let Some(v) = self.recording_zero_timeline_offset_ms {
                my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(10, v);
            }
            my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
            if let Some(v) = self.recording_id.as_ref() {
                os.write_string(1, v)?;
            }
            if let Some(v) = self.start_offset_ms {
                os.write_uint64(2, v)?;
            }
            if let Some(v) = self.duration_ms {
                os.write_uint64(3, v)?;
            }
            if let Some(v) = self.recording_type {
                os.write_enum(4, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
            }
            if let Some(v) = self.delete_on_cleanup {
                os.write_bool(5, v)?;
            }
            if let Some(v) = self.video_manager_clip_id {
                os.write_uint64(6, v)?;
            }
            if let Some(v) = self.video_manager_video_id {
                os.write_uint64(7, v)?;
            }
            if let Some(v) = self.cdn_manifest_url.as_ref() {
                os.write_string(8, v)?;
            }
            if let Some(v) = self.file_size {
                os.write_uint64(9, v)?;
            }
            if let Some(v) = self.recording_zero_timeline_offset_ms {
                os.write_uint64(10, v)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

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

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

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

        fn clear(&mut self) {
            self.recording_id = ::std::option::Option::None;
            self.start_offset_ms = ::std::option::Option::None;
            self.duration_ms = ::std::option::Option::None;
            self.recording_type = ::std::option::Option::None;
            self.delete_on_cleanup = ::std::option::Option::None;
            self.video_manager_clip_id = ::std::option::Option::None;
            self.video_manager_video_id = ::std::option::Option::None;
            self.cdn_manifest_url = ::std::option::Option::None;
            self.file_size = ::std::option::Option::None;
            self.recording_zero_timeline_offset_ms = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Recording {
            static instance: Recording = Recording {
                recording_id: ::std::option::Option::None,
                start_offset_ms: ::std::option::Option::None,
                duration_ms: ::std::option::Option::None,
                recording_type: ::std::option::Option::None,
                delete_on_cleanup: ::std::option::Option::None,
                video_manager_clip_id: ::std::option::Option::None,
                video_manager_video_id: ::std::option::Option::None,
                cdn_manifest_url: ::std::option::Option::None,
                file_size: ::std::option::Option::None,
                recording_zero_timeline_offset_ms: ::std::option::Option::None,
                special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

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

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

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

    // optional uint64 game_id = 1;

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

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

    pub fn has_game_id(&self) -> bool {
        self.game_id.is_some()
    }

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

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

    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.game_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                18 => {
                    self.events.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

// @@protoc_insertion_point(message:CGameRecordingTimelineEvent)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CGameRecordingTimelineEvent {
    // message fields
    // @@protoc_insertion_point(field:CGameRecordingTimelineEvent.game_id)
    pub game_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CGameRecordingTimelineEvent.rt_created)
    pub rt_created: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CGameRecordingTimelineEvent.possible_clip)
    pub possible_clip: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:CGameRecordingTimelineEvent.timeline_id)
    pub timeline_id: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CGameRecordingTimelineEvent.entry_id)
    pub entry_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CGameRecordingTimelineEvent.timeline_offset_ms)
    pub timeline_offset_ms: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CGameRecordingTimelineEvent.duration_ms)
    pub duration_ms: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CGameRecordingTimelineEvent.marker_icon)
    pub marker_icon: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CGameRecordingTimelineEvent.marker_title)
    pub marker_title: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CGameRecordingTimelineEvent.user_marker)
    pub user_marker: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:CGameRecordingTimelineEvent.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint64 game_id = 1;

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

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

    pub fn has_game_id(&self) -> bool {
        self.game_id.is_some()
    }

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

    // optional uint32 rt_created = 2;

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

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

    pub fn has_rt_created(&self) -> bool {
        self.rt_created.is_some()
    }

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

    // optional int32 possible_clip = 3;

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

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

    pub fn has_possible_clip(&self) -> bool {
        self.possible_clip.is_some()
    }

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

    // optional string timeline_id = 4;

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

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

    pub fn has_timeline_id(&self) -> bool {
        self.timeline_id.is_some()
    }

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

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

    // optional uint64 entry_id = 5;

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

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

    pub fn has_entry_id(&self) -> bool {
        self.entry_id.is_some()
    }

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

    // optional uint64 timeline_offset_ms = 6;

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

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

    pub fn has_timeline_offset_ms(&self) -> bool {
        self.timeline_offset_ms.is_some()
    }

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

    // optional uint64 duration_ms = 7;

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

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

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

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

    // optional string marker_icon = 8;

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

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

    pub fn has_marker_icon(&self) -> bool {
        self.marker_icon.is_some()
    }

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

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

    // optional string marker_title = 9;

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

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

    pub fn has_marker_title(&self) -> bool {
        self.marker_title.is_some()
    }

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

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

    // optional bool user_marker = 10;

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

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

    pub fn has_user_marker(&self) -> bool {
        self.user_marker.is_some()
    }

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

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

    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.game_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.rt_created = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.possible_clip = ::std::option::Option::Some(is.read_int32()?);
                },
                34 => {
                    self.timeline_id = ::std::option::Option::Some(is.read_string()?);
                },
                40 => {
                    self.entry_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                48 => {
                    self.timeline_offset_ms = ::std::option::Option::Some(is.read_uint64()?);
                },
                56 => {
                    self.duration_ms = ::std::option::Option::Some(is.read_uint64()?);
                },
                66 => {
                    self.marker_icon = ::std::option::Option::Some(is.read_string()?);
                },
                74 => {
                    self.marker_title = ::std::option::Option::Some(is.read_string()?);
                },
                80 => {
                    self.user_marker = ::std::option::Option::Some(is.read_bool()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.game_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.rt_created {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.possible_clip {
            my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v);
        }
        if let Some(v) = self.timeline_id.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.entry_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(5, v);
        }
        if let Some(v) = self.timeline_offset_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(6, v);
        }
        if let Some(v) = self.duration_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(7, v);
        }
        if let Some(v) = self.marker_icon.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(8, &v);
        }
        if let Some(v) = self.marker_title.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &v);
        }
        if let Some(v) = self.user_marker {
            my_size += 1 + 1;
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.game_id {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.rt_created {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.possible_clip {
            os.write_int32(3, v)?;
        }
        if let Some(v) = self.timeline_id.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.entry_id {
            os.write_uint64(5, v)?;
        }
        if let Some(v) = self.timeline_offset_ms {
            os.write_uint64(6, v)?;
        }
        if let Some(v) = self.duration_ms {
            os.write_uint64(7, v)?;
        }
        if let Some(v) = self.marker_icon.as_ref() {
            os.write_string(8, v)?;
        }
        if let Some(v) = self.marker_title.as_ref() {
            os.write_string(9, v)?;
        }
        if let Some(v) = self.user_marker {
            os.write_bool(10, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.game_id = ::std::option::Option::None;
        self.rt_created = ::std::option::Option::None;
        self.possible_clip = ::std::option::Option::None;
        self.timeline_id = ::std::option::Option::None;
        self.entry_id = ::std::option::Option::None;
        self.timeline_offset_ms = ::std::option::Option::None;
        self.duration_ms = ::std::option::Option::None;
        self.marker_icon = ::std::option::Option::None;
        self.marker_title = ::std::option::Option::None;
        self.user_marker = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CGameRecordingTimelineEvent {
        static instance: CGameRecordingTimelineEvent = CGameRecordingTimelineEvent {
            game_id: ::std::option::Option::None,
            rt_created: ::std::option::Option::None,
            possible_clip: ::std::option::Option::None,
            timeline_id: ::std::option::Option::None,
            entry_id: ::std::option::Option::None,
            timeline_offset_ms: ::std::option::Option::None,
            duration_ms: ::std::option::Option::None,
            marker_icon: ::std::option::Option::None,
            marker_title: ::std::option::Option::None,
            user_marker: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CGameRecordingTag)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CGameRecordingTag {
    // message fields
    // @@protoc_insertion_point(field:CGameRecordingTag.game_id)
    pub game_id: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CGameRecordingTag.tag)
    pub tag: ::steam_vent_proto_common::protobuf::MessageField<CTimelineTag>,
    // @@protoc_insertion_point(field:CGameRecordingTag.references)
    pub references: ::std::vec::Vec<cgame_recording_tag::Timeline>,
    // special fields
    // @@protoc_insertion_point(special_field:CGameRecordingTag.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint64 game_id = 1;

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

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

    pub fn has_game_id(&self) -> bool {
        self.game_id.is_some()
    }

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

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

    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.game_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                18 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.tag)?;
                },
                26 => {
                    self.references.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.game_id {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.tag.as_ref() {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        for v in &self.references {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, 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() -> CGameRecordingTag {
        CGameRecordingTag::new()
    }

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

    fn default_instance() -> &'static CGameRecordingTag {
        static instance: CGameRecordingTag = CGameRecordingTag {
            game_id: ::std::option::Option::None,
            tag: ::steam_vent_proto_common::protobuf::MessageField::none(),
            references: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CGameRecordingTag`
pub mod cgame_recording_tag {
    // @@protoc_insertion_point(message:CGameRecordingTag.Timeline)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Timeline {
        // message fields
        // @@protoc_insertion_point(field:CGameRecordingTag.Timeline.clip_id)
        pub clip_id: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CGameRecordingTag.Timeline.timeline_id)
        pub timeline_id: ::std::option::Option<::std::string::String>,
        // @@protoc_insertion_point(field:CGameRecordingTag.Timeline.offset_ms)
        pub offset_ms: ::std::option::Option<u64>,
        // special fields
        // @@protoc_insertion_point(special_field:CGameRecordingTag.Timeline.special_fields)
        pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
    }

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

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

        // optional string clip_id = 1;

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

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

        pub fn has_clip_id(&self) -> bool {
            self.clip_id.is_some()
        }

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

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

        // optional string timeline_id = 2;

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

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

        pub fn has_timeline_id(&self) -> bool {
            self.timeline_id.is_some()
        }

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

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

        // optional uint64 offset_ms = 3;

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

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

        pub fn has_offset_ms(&self) -> bool {
            self.offset_ms.is_some()
        }

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

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

        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.clip_id = ::std::option::Option::Some(is.read_string()?);
                    },
                    18 => {
                        self.timeline_id = ::std::option::Option::Some(is.read_string()?);
                    },
                    24 => {
                        self.offset_ms = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    tag => {
                        ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

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

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

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

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

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

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

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

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

    // optional string timeline_id = 1;

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

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

    pub fn has_timeline_id(&self) -> bool {
        self.timeline_id.is_some()
    }

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

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

    // optional uint64 entry_id = 2;

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

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

    pub fn has_entry_id(&self) -> bool {
        self.entry_id.is_some()
    }

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

    // optional uint64 timeline_offset_ms = 3;

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

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

    pub fn has_timeline_offset_ms(&self) -> bool {
        self.timeline_offset_ms.is_some()
    }

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

    // optional uint64 duration_ms = 4;

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

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

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

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

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

    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.timeline_id = ::std::option::Option::Some(is.read_string()?);
                },
                16 => {
                    self.entry_id = ::std::option::Option::Some(is.read_uint64()?);
                },
                24 => {
                    self.timeline_offset_ms = ::std::option::Option::Some(is.read_uint64()?);
                },
                32 => {
                    self.duration_ms = ::std::option::Option::Some(is.read_uint64()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn clear(&mut self) {
        self.timeline_id = ::std::option::Option::None;
        self.entry_id = ::std::option::Option::None;
        self.timeline_offset_ms = ::std::option::Option::None;
        self.duration_ms = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CGameRecordingTagInstance {
        static instance: CGameRecordingTagInstance = CGameRecordingTagInstance {
            timeline_id: ::std::option::Option::None,
            entry_id: ::std::option::Option::None,
            timeline_offset_ms: ::std::option::Option::None,
            duration_ms: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CGameRecordingPhase)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CGameRecordingPhase {
    // message fields
    // @@protoc_insertion_point(field:CGameRecordingPhase.phase_id)
    pub phase_id: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CGameRecordingPhase.duration_ms)
    pub duration_ms: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CGameRecordingPhase.tags)
    pub tags: ::std::vec::Vec<cgame_recording_phase::Tag>,
    // @@protoc_insertion_point(field:CGameRecordingPhase.contained_tags)
    pub contained_tags: ::std::vec::Vec<cgame_recording_phase::Tag>,
    // @@protoc_insertion_point(field:CGameRecordingPhase.background_timeline_offset)
    pub background_timeline_offset: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CGameRecordingPhase.attributes)
    pub attributes: ::std::vec::Vec<CPhaseAttribute>,
    // special fields
    // @@protoc_insertion_point(special_field:CGameRecordingPhase.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string phase_id = 4;

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

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

    pub fn has_phase_id(&self) -> bool {
        self.phase_id.is_some()
    }

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

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

    // optional uint64 duration_ms = 5;

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

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

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

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

    // optional uint64 background_timeline_offset = 8;

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

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

    pub fn has_background_timeline_offset(&self) -> bool {
        self.background_timeline_offset.is_some()
    }

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

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

    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 {
                34 => {
                    self.phase_id = ::std::option::Option::Some(is.read_string()?);
                },
                40 => {
                    self.duration_ms = ::std::option::Option::Some(is.read_uint64()?);
                },
                50 => {
                    self.tags.push(is.read_message()?);
                },
                58 => {
                    self.contained_tags.push(is.read_message()?);
                },
                64 => {
                    self.background_timeline_offset = ::std::option::Option::Some(is.read_uint64()?);
                },
                74 => {
                    self.attributes.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.phase_id.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.duration_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(5, v);
        }
        for value in &self.tags {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.contained_tags {
            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.background_timeline_offset {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(8, v);
        }
        for value in &self.attributes {
            let len = value.compute_size();
            my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.phase_id.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.duration_ms {
            os.write_uint64(5, v)?;
        }
        for v in &self.tags {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        };
        for v in &self.contained_tags {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
        };
        if let Some(v) = self.background_timeline_offset {
            os.write_uint64(8, v)?;
        }
        for v in &self.attributes {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(9, 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() -> CGameRecordingPhase {
        CGameRecordingPhase::new()
    }

    fn clear(&mut self) {
        self.phase_id = ::std::option::Option::None;
        self.duration_ms = ::std::option::Option::None;
        self.tags.clear();
        self.contained_tags.clear();
        self.background_timeline_offset = ::std::option::Option::None;
        self.attributes.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CGameRecordingPhase {
        static instance: CGameRecordingPhase = CGameRecordingPhase {
            phase_id: ::std::option::Option::None,
            duration_ms: ::std::option::Option::None,
            tags: ::std::vec::Vec::new(),
            contained_tags: ::std::vec::Vec::new(),
            background_timeline_offset: ::std::option::Option::None,
            attributes: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

        // optional string name = 1;

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

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

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

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

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

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

        // optional string group = 2;

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

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

        pub fn has_group(&self) -> bool {
            self.group.is_some()
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional string name = 1;

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

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

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

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

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

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

    // optional string group = 2;

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

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

    pub fn has_group(&self) -> bool {
        self.group.is_some()
    }

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

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

    // optional string icon = 3;

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

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

    pub fn has_icon(&self) -> bool {
        self.icon.is_some()
    }

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

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

    // optional uint32 priority = 4;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional string group = 1;

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

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

    pub fn has_group(&self) -> bool {
        self.group.is_some()
    }

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

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

    // optional string value = 2;

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

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

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

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

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

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

    // optional uint32 priority = 3;

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

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

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

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

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

    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.group = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.value = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.priority = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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


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

#[allow(unused_imports)]
use crate::enums::*;
#[allow(unused_imports)]
use crate::steammessages_base::*;
#[allow(unused_imports)]
use crate::webuimessages_base::*;
impl ::steam_vent_proto_common::RpcMessage for CGameRecordingFile {
    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 CGameRecordingClipFile {
    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 CGameRecordingTimelineMetadata {
    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 CGameRecordingPostGameSummary {
    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 CGameRecordingTimelineEvent {
    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 CGameRecordingTag {
    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 CGameRecordingTagInstance {
    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 CGameRecordingPhase {
    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 CTimelineTag {
    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 CPhaseAttribute {
    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
    }
}
