// This file is generated by rust-protobuf 3.7.2. 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 `playlist_annotate3.proto`

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

// @@protoc_insertion_point(message:spotify_playlist_annotate3.proto.TakedownRequest)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct TakedownRequest {
    // message fields
    // @@protoc_insertion_point(field:spotify_playlist_annotate3.proto.TakedownRequest.abuse_report_state)
    pub abuse_report_state: ::std::option::Option<::protobuf::EnumOrUnknown<AbuseReportState>>,
    // special fields
    // @@protoc_insertion_point(special_field:spotify_playlist_annotate3.proto.TakedownRequest.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional .spotify_playlist_annotate3.proto.AbuseReportState abuse_report_state = 1;

    pub fn abuse_report_state(&self) -> AbuseReportState {
        match self.abuse_report_state {
            Some(e) => e.enum_value_or(AbuseReportState::OK),
            None => AbuseReportState::OK,
        }
    }

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

    pub fn has_abuse_report_state(&self) -> bool {
        self.abuse_report_state.is_some()
    }

    // Param is passed by value, moved
    pub fn set_abuse_report_state(&mut self, v: AbuseReportState) {
        self.abuse_report_state = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(1);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "abuse_report_state",
            |m: &TakedownRequest| { &m.abuse_report_state },
            |m: &mut TakedownRequest| { &mut m.abuse_report_state },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<TakedownRequest>(
            "TakedownRequest",
            fields,
            oneofs,
        )
    }
}

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.abuse_report_state = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                tag => {
                    ::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.abuse_report_state {
            my_size += ::protobuf::rt::int32_size(1, v.value());
        }
        my_size += ::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 ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.abuse_report_state {
            os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

impl ::protobuf::MessageFull for TakedownRequest {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("TakedownRequest").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for TakedownRequest {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:spotify_playlist_annotate3.proto.AnnotateRequest)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AnnotateRequest {
    // message fields
    // @@protoc_insertion_point(field:spotify_playlist_annotate3.proto.AnnotateRequest.description)
    pub description: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:spotify_playlist_annotate3.proto.AnnotateRequest.image_uri)
    pub image_uri: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:spotify_playlist_annotate3.proto.AnnotateRequest.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional string description = 1;

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

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

    pub fn has_description(&self) -> bool {
        self.description.is_some()
    }

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

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

    // optional string image_uri = 2;

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

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

    pub fn has_image_uri(&self) -> bool {
        self.image_uri.is_some()
    }

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(2);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "description",
            |m: &AnnotateRequest| { &m.description },
            |m: &mut AnnotateRequest| { &mut m.description },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "image_uri",
            |m: &AnnotateRequest| { &m.image_uri },
            |m: &mut AnnotateRequest| { &mut m.image_uri },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<AnnotateRequest>(
            "AnnotateRequest",
            fields,
            oneofs,
        )
    }
}

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.description = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.image_uri = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::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.description.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.image_uri.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        my_size += ::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 ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.description.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.image_uri.as_ref() {
            os.write_string(2, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

impl ::protobuf::MessageFull for AnnotateRequest {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("AnnotateRequest").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for AnnotateRequest {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:spotify_playlist_annotate3.proto.TranscodedPicture)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct TranscodedPicture {
    // message fields
    // @@protoc_insertion_point(field:spotify_playlist_annotate3.proto.TranscodedPicture.target_name)
    pub target_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:spotify_playlist_annotate3.proto.TranscodedPicture.uri)
    pub uri: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:spotify_playlist_annotate3.proto.TranscodedPicture.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional string target_name = 1;

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

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

    pub fn has_target_name(&self) -> bool {
        self.target_name.is_some()
    }

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

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

    // optional string uri = 2;

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

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

    pub fn has_uri(&self) -> bool {
        self.uri.is_some()
    }

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(2);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "target_name",
            |m: &TranscodedPicture| { &m.target_name },
            |m: &mut TranscodedPicture| { &mut m.target_name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "uri",
            |m: &TranscodedPicture| { &m.uri },
            |m: &mut TranscodedPicture| { &mut m.uri },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<TranscodedPicture>(
            "TranscodedPicture",
            fields,
            oneofs,
        )
    }
}

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.target_name = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.uri = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::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.target_name.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.uri.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        my_size += ::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 ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.target_name.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.uri.as_ref() {
            os.write_string(2, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

impl ::protobuf::MessageFull for TranscodedPicture {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("TranscodedPicture").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for TranscodedPicture {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:spotify_playlist_annotate3.proto.PlaylistAnnotation)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PlaylistAnnotation {
    // message fields
    // @@protoc_insertion_point(field:spotify_playlist_annotate3.proto.PlaylistAnnotation.description)
    pub description: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:spotify_playlist_annotate3.proto.PlaylistAnnotation.picture)
    pub picture: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:spotify_playlist_annotate3.proto.PlaylistAnnotation.deprecated_render_features)
    pub deprecated_render_features: ::std::option::Option<::protobuf::EnumOrUnknown<RenderFeatures>>,
    // @@protoc_insertion_point(field:spotify_playlist_annotate3.proto.PlaylistAnnotation.transcoded_picture)
    pub transcoded_picture: ::std::vec::Vec<TranscodedPicture>,
    // @@protoc_insertion_point(field:spotify_playlist_annotate3.proto.PlaylistAnnotation.is_abuse_reporting_enabled)
    pub is_abuse_reporting_enabled: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:spotify_playlist_annotate3.proto.PlaylistAnnotation.abuse_report_state)
    pub abuse_report_state: ::std::option::Option<::protobuf::EnumOrUnknown<AbuseReportState>>,
    // special fields
    // @@protoc_insertion_point(special_field:spotify_playlist_annotate3.proto.PlaylistAnnotation.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional string description = 1;

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

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

    pub fn has_description(&self) -> bool {
        self.description.is_some()
    }

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

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

    // optional string picture = 2;

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

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

    pub fn has_picture(&self) -> bool {
        self.picture.is_some()
    }

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

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

    // optional .spotify_playlist_annotate3.proto.RenderFeatures deprecated_render_features = 3;

    pub fn deprecated_render_features(&self) -> RenderFeatures {
        match self.deprecated_render_features {
            Some(e) => e.enum_value_or(RenderFeatures::NORMAL_FEATURES),
            None => RenderFeatures::NORMAL_FEATURES,
        }
    }

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

    pub fn has_deprecated_render_features(&self) -> bool {
        self.deprecated_render_features.is_some()
    }

    // Param is passed by value, moved
    pub fn set_deprecated_render_features(&mut self, v: RenderFeatures) {
        self.deprecated_render_features = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
    }

    // optional bool is_abuse_reporting_enabled = 6;

    pub fn is_abuse_reporting_enabled(&self) -> bool {
        self.is_abuse_reporting_enabled.unwrap_or(true)
    }

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

    pub fn has_is_abuse_reporting_enabled(&self) -> bool {
        self.is_abuse_reporting_enabled.is_some()
    }

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

    // optional .spotify_playlist_annotate3.proto.AbuseReportState abuse_report_state = 7;

    pub fn abuse_report_state(&self) -> AbuseReportState {
        match self.abuse_report_state {
            Some(e) => e.enum_value_or(AbuseReportState::OK),
            None => AbuseReportState::OK,
        }
    }

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

    pub fn has_abuse_report_state(&self) -> bool {
        self.abuse_report_state.is_some()
    }

    // Param is passed by value, moved
    pub fn set_abuse_report_state(&mut self, v: AbuseReportState) {
        self.abuse_report_state = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(6);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "description",
            |m: &PlaylistAnnotation| { &m.description },
            |m: &mut PlaylistAnnotation| { &mut m.description },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "picture",
            |m: &PlaylistAnnotation| { &m.picture },
            |m: &mut PlaylistAnnotation| { &mut m.picture },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "deprecated_render_features",
            |m: &PlaylistAnnotation| { &m.deprecated_render_features },
            |m: &mut PlaylistAnnotation| { &mut m.deprecated_render_features },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "transcoded_picture",
            |m: &PlaylistAnnotation| { &m.transcoded_picture },
            |m: &mut PlaylistAnnotation| { &mut m.transcoded_picture },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "is_abuse_reporting_enabled",
            |m: &PlaylistAnnotation| { &m.is_abuse_reporting_enabled },
            |m: &mut PlaylistAnnotation| { &mut m.is_abuse_reporting_enabled },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "abuse_report_state",
            |m: &PlaylistAnnotation| { &m.abuse_report_state },
            |m: &mut PlaylistAnnotation| { &mut m.abuse_report_state },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PlaylistAnnotation>(
            "PlaylistAnnotation",
            fields,
            oneofs,
        )
    }
}

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.description = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.picture = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.deprecated_render_features = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                34 => {
                    self.transcoded_picture.push(is.read_message()?);
                },
                48 => {
                    self.is_abuse_reporting_enabled = ::std::option::Option::Some(is.read_bool()?);
                },
                56 => {
                    self.abuse_report_state = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                tag => {
                    ::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.description.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.picture.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.deprecated_render_features {
            my_size += ::protobuf::rt::int32_size(3, v.value());
        }
        for value in &self.transcoded_picture {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.is_abuse_reporting_enabled {
            my_size += 1 + 1;
        }
        if let Some(v) = self.abuse_report_state {
            my_size += ::protobuf::rt::int32_size(7, v.value());
        }
        my_size += ::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 ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.description.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.picture.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.deprecated_render_features {
            os.write_enum(3, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        for v in &self.transcoded_picture {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        if let Some(v) = self.is_abuse_reporting_enabled {
            os.write_bool(6, v)?;
        }
        if let Some(v) = self.abuse_report_state {
            os.write_enum(7, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.description = ::std::option::Option::None;
        self.picture = ::std::option::Option::None;
        self.deprecated_render_features = ::std::option::Option::None;
        self.transcoded_picture.clear();
        self.is_abuse_reporting_enabled = ::std::option::Option::None;
        self.abuse_report_state = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static PlaylistAnnotation {
        static instance: PlaylistAnnotation = PlaylistAnnotation {
            description: ::std::option::Option::None,
            picture: ::std::option::Option::None,
            deprecated_render_features: ::std::option::Option::None,
            transcoded_picture: ::std::vec::Vec::new(),
            is_abuse_reporting_enabled: ::std::option::Option::None,
            abuse_report_state: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for PlaylistAnnotation {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("PlaylistAnnotation").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for PlaylistAnnotation {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:spotify_playlist_annotate3.proto.RenderFeatures)
pub enum RenderFeatures {
    // @@protoc_insertion_point(enum_value:spotify_playlist_annotate3.proto.RenderFeatures.NORMAL_FEATURES)
    NORMAL_FEATURES = 1,
    // @@protoc_insertion_point(enum_value:spotify_playlist_annotate3.proto.RenderFeatures.EXTENDED_FEATURES)
    EXTENDED_FEATURES = 2,
}

impl ::protobuf::Enum for RenderFeatures {
    const NAME: &'static str = "RenderFeatures";

    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<RenderFeatures> {
        match value {
            1 => ::std::option::Option::Some(RenderFeatures::NORMAL_FEATURES),
            2 => ::std::option::Option::Some(RenderFeatures::EXTENDED_FEATURES),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<RenderFeatures> {
        match str {
            "NORMAL_FEATURES" => ::std::option::Option::Some(RenderFeatures::NORMAL_FEATURES),
            "EXTENDED_FEATURES" => ::std::option::Option::Some(RenderFeatures::EXTENDED_FEATURES),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [RenderFeatures] = &[
        RenderFeatures::NORMAL_FEATURES,
        RenderFeatures::EXTENDED_FEATURES,
    ];
}

impl ::protobuf::EnumFull for RenderFeatures {
    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().enum_by_package_relative_name("RenderFeatures").unwrap()).clone()
    }

    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
        let index = match self {
            RenderFeatures::NORMAL_FEATURES => 0,
            RenderFeatures::EXTENDED_FEATURES => 1,
        };
        Self::enum_descriptor().value_by_index(index)
    }
}

// Note, `Default` is implemented although default value is not 0
impl ::std::default::Default for RenderFeatures {
    fn default() -> Self {
        RenderFeatures::NORMAL_FEATURES
    }
}

impl RenderFeatures {
    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<RenderFeatures>("RenderFeatures")
    }
}

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:spotify_playlist_annotate3.proto.AbuseReportState)
pub enum AbuseReportState {
    // @@protoc_insertion_point(enum_value:spotify_playlist_annotate3.proto.AbuseReportState.OK)
    OK = 0,
    // @@protoc_insertion_point(enum_value:spotify_playlist_annotate3.proto.AbuseReportState.TAKEN_DOWN)
    TAKEN_DOWN = 1,
}

impl ::protobuf::Enum for AbuseReportState {
    const NAME: &'static str = "AbuseReportState";

    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<AbuseReportState> {
        match value {
            0 => ::std::option::Option::Some(AbuseReportState::OK),
            1 => ::std::option::Option::Some(AbuseReportState::TAKEN_DOWN),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<AbuseReportState> {
        match str {
            "OK" => ::std::option::Option::Some(AbuseReportState::OK),
            "TAKEN_DOWN" => ::std::option::Option::Some(AbuseReportState::TAKEN_DOWN),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [AbuseReportState] = &[
        AbuseReportState::OK,
        AbuseReportState::TAKEN_DOWN,
    ];
}

impl ::protobuf::EnumFull for AbuseReportState {
    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().enum_by_package_relative_name("AbuseReportState").unwrap()).clone()
    }

    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
        let index = *self as usize;
        Self::enum_descriptor().value_by_index(index)
    }
}

impl ::std::default::Default for AbuseReportState {
    fn default() -> Self {
        AbuseReportState::OK
    }
}

impl AbuseReportState {
    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<AbuseReportState>("AbuseReportState")
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x18playlist_annotate3.proto\x12\x20spotify_playlist_annotate3.proto\"\
    s\n\x0fTakedownRequest\x12`\n\x12abuse_report_state\x18\x01\x20\x01(\x0e\
    22.spotify_playlist_annotate3.proto.AbuseReportStateR\x10abuseReportStat\
    e\"P\n\x0fAnnotateRequest\x12\x20\n\x0bdescription\x18\x01\x20\x01(\tR\
    \x0bdescription\x12\x1b\n\timage_uri\x18\x02\x20\x01(\tR\x08imageUri\"F\
    \n\x11TranscodedPicture\x12\x1f\n\x0btarget_name\x18\x01\x20\x01(\tR\nta\
    rgetName\x12\x10\n\x03uri\x18\x02\x20\x01(\tR\x03uri\"\xe7\x03\n\x12Play\
    listAnnotation\x12\x20\n\x0bdescription\x18\x01\x20\x01(\tR\x0bdescripti\
    on\x12\x18\n\x07picture\x18\x02\x20\x01(\tR\x07picture\x12\x83\x01\n\x1a\
    deprecated_render_features\x18\x03\x20\x01(\x0e20.spotify_playlist_annot\
    ate3.proto.RenderFeatures:\x0fNORMAL_FEATURESR\x18deprecatedRenderFeatur\
    esB\x02\x18\x01\x12b\n\x12transcoded_picture\x18\x04\x20\x03(\x0b23.spot\
    ify_playlist_annotate3.proto.TranscodedPictureR\x11transcodedPicture\x12\
    C\n\x1ais_abuse_reporting_enabled\x18\x06\x20\x01(\x08:\x04trueR\x17isAb\
    useReportingEnabledB\0\x12f\n\x12abuse_report_state\x18\x07\x20\x01(\x0e\
    22.spotify_playlist_annotate3.proto.AbuseReportState:\x02OKR\x10abuseRep\
    ortStateB\0*<\n\x0eRenderFeatures\x12\x13\n\x0fNORMAL_FEATURES\x10\x01\
    \x12\x15\n\x11EXTENDED_FEATURES\x10\x02**\n\x10AbuseReportState\x12\x06\
    \n\x02OK\x10\0\x12\x0e\n\nTAKEN_DOWN\x10\x01B(\n$com.spotify.playlist_an\
    notate3.protoH\x02b\x06proto2\
";

/// `FileDescriptorProto` object which was a source for this generated file
fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
    file_descriptor_proto_lazy.get(|| {
        ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
    })
}

/// `FileDescriptor` object which allows dynamic access to files
pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
    static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
    static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
    file_descriptor.get(|| {
        let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
            let mut deps = ::std::vec::Vec::with_capacity(0);
            let mut messages = ::std::vec::Vec::with_capacity(4);
            messages.push(TakedownRequest::generated_message_descriptor_data());
            messages.push(AnnotateRequest::generated_message_descriptor_data());
            messages.push(TranscodedPicture::generated_message_descriptor_data());
            messages.push(PlaylistAnnotation::generated_message_descriptor_data());
            let mut enums = ::std::vec::Vec::with_capacity(2);
            enums.push(RenderFeatures::generated_enum_descriptor_data());
            enums.push(AbuseReportState::generated_enum_descriptor_data());
            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
                file_descriptor_proto(),
                deps,
                messages,
                enums,
            )
        });
        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
    })
}
