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

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

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

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

//! Generated file from `steammessages_clientserver_video.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:CMsgVideoGameRecordingRepresentation)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgVideoGameRecordingRepresentation {
    // message fields
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingRepresentation.representation_name)
    pub representation_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingRepresentation.horizontal_resolution)
    pub horizontal_resolution: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingRepresentation.vertical_resolution)
    pub vertical_resolution: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingRepresentation.frame_rate)
    pub frame_rate: ::std::option::Option<f64>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingRepresentation.bandwidth)
    pub bandwidth: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingRepresentation.audio_sample_rate)
    pub audio_sample_rate: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingRepresentation.frame_rate_string)
    pub frame_rate_string: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingRepresentation.codec)
    pub codec: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingRepresentation.audio_channel_config)
    pub audio_channel_config: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingRepresentation.segment_info)
    pub segment_info: ::std::vec::Vec<CVideo_GameRecordingSegmentInfo>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgVideoGameRecordingRepresentation.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string representation_name = 2;

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

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

    pub fn has_representation_name(&self) -> bool {
        self.representation_name.is_some()
    }

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

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

    // optional uint32 horizontal_resolution = 3;

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

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

    pub fn has_horizontal_resolution(&self) -> bool {
        self.horizontal_resolution.is_some()
    }

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

    // optional uint32 vertical_resolution = 4;

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

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

    pub fn has_vertical_resolution(&self) -> bool {
        self.vertical_resolution.is_some()
    }

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

    // optional double frame_rate = 5;

    pub fn frame_rate(&self) -> f64 {
        self.frame_rate.unwrap_or(0.)
    }

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

    pub fn has_frame_rate(&self) -> bool {
        self.frame_rate.is_some()
    }

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

    // optional uint32 bandwidth = 6;

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

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

    pub fn has_bandwidth(&self) -> bool {
        self.bandwidth.is_some()
    }

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

    // optional uint32 audio_sample_rate = 7;

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

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

    pub fn has_audio_sample_rate(&self) -> bool {
        self.audio_sample_rate.is_some()
    }

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

    // optional string frame_rate_string = 8;

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

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

    pub fn has_frame_rate_string(&self) -> bool {
        self.frame_rate_string.is_some()
    }

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

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

    // optional string codec = 9;

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

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

    pub fn has_codec(&self) -> bool {
        self.codec.is_some()
    }

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

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

    // optional uint32 audio_channel_config = 10;

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

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

    pub fn has_audio_channel_config(&self) -> bool {
        self.audio_channel_config.is_some()
    }

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

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

    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 {
                18 => {
                    self.representation_name = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.horizontal_resolution = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.vertical_resolution = ::std::option::Option::Some(is.read_uint32()?);
                },
                41 => {
                    self.frame_rate = ::std::option::Option::Some(is.read_double()?);
                },
                48 => {
                    self.bandwidth = ::std::option::Option::Some(is.read_uint32()?);
                },
                56 => {
                    self.audio_sample_rate = ::std::option::Option::Some(is.read_uint32()?);
                },
                66 => {
                    self.frame_rate_string = ::std::option::Option::Some(is.read_string()?);
                },
                74 => {
                    self.codec = ::std::option::Option::Some(is.read_string()?);
                },
                80 => {
                    self.audio_channel_config = ::std::option::Option::Some(is.read_uint32()?);
                },
                90 => {
                    self.segment_info.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.representation_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.horizontal_resolution {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.vertical_resolution {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.frame_rate {
            my_size += 1 + 8;
        }
        if let Some(v) = self.bandwidth {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.audio_sample_rate {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(7, v);
        }
        if let Some(v) = self.frame_rate_string.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(8, &v);
        }
        if let Some(v) = self.codec.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &v);
        }
        if let Some(v) = self.audio_channel_config {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(10, v);
        }
        for value in &self.segment_info {
            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.representation_name.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.horizontal_resolution {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.vertical_resolution {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.frame_rate {
            os.write_double(5, v)?;
        }
        if let Some(v) = self.bandwidth {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.audio_sample_rate {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.frame_rate_string.as_ref() {
            os.write_string(8, v)?;
        }
        if let Some(v) = self.codec.as_ref() {
            os.write_string(9, v)?;
        }
        if let Some(v) = self.audio_channel_config {
            os.write_uint32(10, v)?;
        }
        for v in &self.segment_info {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(11, 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() -> CMsgVideoGameRecordingRepresentation {
        CMsgVideoGameRecordingRepresentation::new()
    }

    fn clear(&mut self) {
        self.representation_name = ::std::option::Option::None;
        self.horizontal_resolution = ::std::option::Option::None;
        self.vertical_resolution = ::std::option::Option::None;
        self.frame_rate = ::std::option::Option::None;
        self.bandwidth = ::std::option::Option::None;
        self.audio_sample_rate = ::std::option::Option::None;
        self.frame_rate_string = ::std::option::Option::None;
        self.codec = ::std::option::Option::None;
        self.audio_channel_config = ::std::option::Option::None;
        self.segment_info.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgVideoGameRecordingRepresentation {
        static instance: CMsgVideoGameRecordingRepresentation = CMsgVideoGameRecordingRepresentation {
            representation_name: ::std::option::Option::None,
            horizontal_resolution: ::std::option::Option::None,
            vertical_resolution: ::std::option::Option::None,
            frame_rate: ::std::option::Option::None,
            bandwidth: ::std::option::Option::None,
            audio_sample_rate: ::std::option::Option::None,
            frame_rate_string: ::std::option::Option::None,
            codec: ::std::option::Option::None,
            audio_channel_config: ::std::option::Option::None,
            segment_info: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgVideoGameRecordingComponent)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgVideoGameRecordingComponent {
    // message fields
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingComponent.component_name)
    pub component_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingComponent.contents)
    pub contents: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingComponent.segment_size)
    pub segment_size: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingComponent.file_type)
    pub file_type: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingComponent.representations)
    pub representations: ::std::vec::Vec<CMsgVideoGameRecordingRepresentation>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgVideoGameRecordingComponent.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional string component_name = 1;

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

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

    pub fn has_component_name(&self) -> bool {
        self.component_name.is_some()
    }

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

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

    // optional uint32 contents = 2;

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

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

    pub fn has_contents(&self) -> bool {
        self.contents.is_some()
    }

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

    // optional uint32 segment_size = 3;

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

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

    pub fn has_segment_size(&self) -> bool {
        self.segment_size.is_some()
    }

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

    // optional string file_type = 4;

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

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

    pub fn has_file_type(&self) -> bool {
        self.file_type.is_some()
    }

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

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

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

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

    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.component_name = ::std::option::Option::Some(is.read_string()?);
                },
                16 => {
                    self.contents = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.segment_size = ::std::option::Option::Some(is.read_uint32()?);
                },
                34 => {
                    self.file_type = ::std::option::Option::Some(is.read_string()?);
                },
                42 => {
                    self.representations.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.component_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.contents {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.segment_size {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.file_type.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        for value in &self.representations {
            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.component_name.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.contents {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.segment_size {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.file_type.as_ref() {
            os.write_string(4, v)?;
        }
        for v in &self.representations {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, 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() -> CMsgVideoGameRecordingComponent {
        CMsgVideoGameRecordingComponent::new()
    }

    fn clear(&mut self) {
        self.component_name = ::std::option::Option::None;
        self.contents = ::std::option::Option::None;
        self.segment_size = ::std::option::Option::None;
        self.file_type = ::std::option::Option::None;
        self.representations.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgVideoGameRecordingComponent {
        static instance: CMsgVideoGameRecordingComponent = CMsgVideoGameRecordingComponent {
            component_name: ::std::option::Option::None,
            contents: ::std::option::Option::None,
            segment_size: ::std::option::Option::None,
            file_type: ::std::option::Option::None,
            representations: ::std::vec::Vec::new(),
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:CMsgVideoGameRecordingDef)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgVideoGameRecordingDef {
    // message fields
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingDef.steamid)
    pub steamid: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingDef.app_id)
    pub app_id: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingDef.num_segments)
    pub num_segments: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingDef.length_milliseconds)
    pub length_milliseconds: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingDef.segment_duration_timescale)
    pub segment_duration_timescale: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingDef.segment_duration)
    pub segment_duration: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingDef.components)
    pub components: ::std::vec::Vec<CMsgVideoGameRecordingComponent>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingDef.start_time_ms)
    pub start_time_ms: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:CMsgVideoGameRecordingDef.start_offset_in_timeline_ms)
    pub start_offset_in_timeline_ms: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:CMsgVideoGameRecordingDef.special_fields)
    pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
}

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

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

    // optional uint64 steamid = 1;

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

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

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

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

    // optional uint32 app_id = 2;

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

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

    pub fn has_app_id(&self) -> bool {
        self.app_id.is_some()
    }

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

    // optional uint32 num_segments = 3;

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

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

    pub fn has_num_segments(&self) -> bool {
        self.num_segments.is_some()
    }

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

    // optional uint32 length_milliseconds = 4;

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

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

    pub fn has_length_milliseconds(&self) -> bool {
        self.length_milliseconds.is_some()
    }

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

    // optional uint32 segment_duration_timescale = 5;

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

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

    pub fn has_segment_duration_timescale(&self) -> bool {
        self.segment_duration_timescale.is_some()
    }

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

    // optional uint32 segment_duration = 6;

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

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

    pub fn has_segment_duration(&self) -> bool {
        self.segment_duration.is_some()
    }

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

    // optional uint32 start_time_ms = 8;

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

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

    pub fn has_start_time_ms(&self) -> bool {
        self.start_time_ms.is_some()
    }

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

    // optional uint32 start_offset_in_timeline_ms = 9;

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

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

    pub fn has_start_offset_in_timeline_ms(&self) -> bool {
        self.start_offset_in_timeline_ms.is_some()
    }

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

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

    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.steamid = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.app_id = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.num_segments = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.length_milliseconds = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.segment_duration_timescale = ::std::option::Option::Some(is.read_uint32()?);
                },
                48 => {
                    self.segment_duration = ::std::option::Option::Some(is.read_uint32()?);
                },
                58 => {
                    self.components.push(is.read_message()?);
                },
                64 => {
                    self.start_time_ms = ::std::option::Option::Some(is.read_uint32()?);
                },
                72 => {
                    self.start_offset_in_timeline_ms = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.steamid {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
        }
        if let Some(v) = self.app_id {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.num_segments {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.length_milliseconds {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.segment_duration_timescale {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.segment_duration {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
        }
        for value in &self.components {
            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.start_time_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(8, v);
        }
        if let Some(v) = self.start_offset_in_timeline_ms {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(9, v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        if let Some(v) = self.steamid {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.app_id {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.num_segments {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.length_milliseconds {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.segment_duration_timescale {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.segment_duration {
            os.write_uint32(6, v)?;
        }
        for v in &self.components {
            ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
        };
        if let Some(v) = self.start_time_ms {
            os.write_uint32(8, v)?;
        }
        if let Some(v) = self.start_offset_in_timeline_ms {
            os.write_uint32(9, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.app_id = ::std::option::Option::None;
        self.num_segments = ::std::option::Option::None;
        self.length_milliseconds = ::std::option::Option::None;
        self.segment_duration_timescale = ::std::option::Option::None;
        self.segment_duration = ::std::option::Option::None;
        self.components.clear();
        self.start_time_ms = ::std::option::Option::None;
        self.start_offset_in_timeline_ms = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CMsgVideoGameRecordingDef {
        static instance: CMsgVideoGameRecordingDef = CMsgVideoGameRecordingDef {
            steamid: ::std::option::Option::None,
            app_id: ::std::option::Option::None,
            num_segments: ::std::option::Option::None,
            length_milliseconds: ::std::option::Option::None,
            segment_duration_timescale: ::std::option::Option::None,
            segment_duration: ::std::option::Option::None,
            components: ::std::vec::Vec::new(),
            start_time_ms: ::std::option::Option::None,
            start_offset_in_timeline_ms: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional uint32 segment_number = 1;

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

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

    pub fn has_segment_number(&self) -> bool {
        self.segment_number.is_some()
    }

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

    // optional uint64 segment_size_bytes = 2;

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

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

    pub fn has_segment_size_bytes(&self) -> bool {
        self.segment_size_bytes.is_some()
    }

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

    // optional string component_name = 3;

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

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

    pub fn has_component_name(&self) -> bool {
        self.component_name.is_some()
    }

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

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

    // optional string representation_name = 4;

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

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

    pub fn has_representation_name(&self) -> bool {
        self.representation_name.is_some()
    }

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

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

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

    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.segment_number = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.segment_size_bytes = ::std::option::Option::Some(is.read_uint64()?);
                },
                26 => {
                    self.component_name = ::std::option::Option::Some(is.read_string()?);
                },
                34 => {
                    self.representation_name = ::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.segment_number {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.segment_size_bytes {
            my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
        }
        if let Some(v) = self.component_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.representation_name.as_ref() {
            my_size += ::steam_vent_proto_common::protobuf::rt::string_size(4, &v);
        }
        my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

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

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

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

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

    fn clear(&mut self) {
        self.segment_number = ::std::option::Option::None;
        self.segment_size_bytes = ::std::option::Option::None;
        self.component_name = ::std::option::Option::None;
        self.representation_name = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CVideo_GameRecordingSegmentInfo {
        static instance: CVideo_GameRecordingSegmentInfo = CVideo_GameRecordingSegmentInfo {
            segment_number: ::std::option::Option::None,
            segment_size_bytes: ::std::option::Option::None,
            component_name: ::std::option::Option::None,
            representation_name: ::std::option::Option::None,
            special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

    // optional string url_host = 2;

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

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

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

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

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

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

    // optional string url_path = 3;

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

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

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

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

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

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

    // optional bool use_https = 4;

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.segment_info)?;
                },
                18 => {
                    self.url_host = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    self.url_path = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.use_https = ::std::option::Option::Some(is.read_bool()?);
                },
                42 => {
                    self.request_headers.push(is.read_message()?);
                },
                tag => {
                    ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

        // optional string name = 1;

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

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

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

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

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

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

        // optional string value = 2;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

#[allow(unused_imports)]
use crate::steammessages_base::*;
impl ::steam_vent_proto_common::RpcMessage for CMsgVideoGameRecordingRepresentation {
    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 CMsgVideoGameRecordingComponent {
    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 CMsgVideoGameRecordingDef {
    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 CVideo_GameRecordingSegmentInfo {
    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 CVideo_GameRecordingSegmentUploadInfo {
    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
    }
}
