tensorflow-serving-client 2.3.0

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

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

#![cfg_attr(rustfmt, rustfmt_skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `tensorflow/core/protobuf/struct.proto`

use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;

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

#[derive(PartialEq,Clone,Default)]
pub struct StructuredValue {
    // message oneof groups
    pub kind: ::std::option::Option<StructuredValue_oneof_kind>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

#[derive(Clone,PartialEq,Debug)]
pub enum StructuredValue_oneof_kind {
    none_value(NoneValue),
    float64_value(f64),
    int64_value(i64),
    string_value(::std::string::String),
    bool_value(bool),
    tensor_shape_value(super::tensor_shape::TensorShapeProto),
    tensor_dtype_value(super::types::DataType),
    tensor_spec_value(TensorSpecProto),
    type_spec_value(TypeSpecProto),
    bounded_tensor_spec_value(BoundedTensorSpecProto),
    list_value(ListValue),
    tuple_value(TupleValue),
    dict_value(DictValue),
    named_tuple_value(NamedTupleValue),
}

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

    // .tensorflow.NoneValue none_value = 1;


    pub fn get_none_value(&self) -> &NoneValue {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(ref v)) => v,
            _ => NoneValue::default_instance(),
        }
    }
    pub fn clear_none_value(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_none_value(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_none_value(&mut self, v: NoneValue) {
        self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(v))
    }

    // Mutable pointer to the field.
    pub fn mut_none_value(&mut self) -> &mut NoneValue {
        if let ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(_)) = self.kind {
        } else {
            self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(NoneValue::new()));
        }
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_none_value(&mut self) -> NoneValue {
        if self.has_none_value() {
            match self.kind.take() {
                ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(v)) => v,
                _ => panic!(),
            }
        } else {
            NoneValue::new()
        }
    }

    // double float64_value = 11;


    pub fn get_float64_value(&self) -> f64 {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::float64_value(v)) => v,
            _ => 0.,
        }
    }
    pub fn clear_float64_value(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_float64_value(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::float64_value(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_float64_value(&mut self, v: f64) {
        self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::float64_value(v))
    }

    // sint64 int64_value = 12;


    pub fn get_int64_value(&self) -> i64 {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::int64_value(v)) => v,
            _ => 0,
        }
    }
    pub fn clear_int64_value(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_int64_value(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::int64_value(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_int64_value(&mut self, v: i64) {
        self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::int64_value(v))
    }

    // string string_value = 13;


    pub fn get_string_value(&self) -> &str {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::string_value(ref v)) => v,
            _ => "",
        }
    }
    pub fn clear_string_value(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_string_value(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::string_value(..)) => true,
            _ => false,
        }
    }

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

    // Mutable pointer to the field.
    pub fn mut_string_value(&mut self) -> &mut ::std::string::String {
        if let ::std::option::Option::Some(StructuredValue_oneof_kind::string_value(_)) = self.kind {
        } else {
            self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::string_value(::std::string::String::new()));
        }
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::string_value(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_string_value(&mut self) -> ::std::string::String {
        if self.has_string_value() {
            match self.kind.take() {
                ::std::option::Option::Some(StructuredValue_oneof_kind::string_value(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::string::String::new()
        }
    }

    // bool bool_value = 14;


    pub fn get_bool_value(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::bool_value(v)) => v,
            _ => false,
        }
    }
    pub fn clear_bool_value(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_bool_value(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::bool_value(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_bool_value(&mut self, v: bool) {
        self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::bool_value(v))
    }

    // .tensorflow.TensorShapeProto tensor_shape_value = 31;


    pub fn get_tensor_shape_value(&self) -> &super::tensor_shape::TensorShapeProto {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(ref v)) => v,
            _ => super::tensor_shape::TensorShapeProto::default_instance(),
        }
    }
    pub fn clear_tensor_shape_value(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_tensor_shape_value(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_tensor_shape_value(&mut self, v: super::tensor_shape::TensorShapeProto) {
        self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(v))
    }

    // Mutable pointer to the field.
    pub fn mut_tensor_shape_value(&mut self) -> &mut super::tensor_shape::TensorShapeProto {
        if let ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(_)) = self.kind {
        } else {
            self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(super::tensor_shape::TensorShapeProto::new()));
        }
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_tensor_shape_value(&mut self) -> super::tensor_shape::TensorShapeProto {
        if self.has_tensor_shape_value() {
            match self.kind.take() {
                ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(v)) => v,
                _ => panic!(),
            }
        } else {
            super::tensor_shape::TensorShapeProto::new()
        }
    }

    // .tensorflow.DataType tensor_dtype_value = 32;


    pub fn get_tensor_dtype_value(&self) -> super::types::DataType {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_dtype_value(v)) => v,
            _ => super::types::DataType::DT_INVALID,
        }
    }
    pub fn clear_tensor_dtype_value(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_tensor_dtype_value(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_dtype_value(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_tensor_dtype_value(&mut self, v: super::types::DataType) {
        self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_dtype_value(v))
    }

    // .tensorflow.TensorSpecProto tensor_spec_value = 33;


    pub fn get_tensor_spec_value(&self) -> &TensorSpecProto {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(ref v)) => v,
            _ => TensorSpecProto::default_instance(),
        }
    }
    pub fn clear_tensor_spec_value(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_tensor_spec_value(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_tensor_spec_value(&mut self, v: TensorSpecProto) {
        self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(v))
    }

    // Mutable pointer to the field.
    pub fn mut_tensor_spec_value(&mut self) -> &mut TensorSpecProto {
        if let ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(_)) = self.kind {
        } else {
            self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(TensorSpecProto::new()));
        }
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_tensor_spec_value(&mut self) -> TensorSpecProto {
        if self.has_tensor_spec_value() {
            match self.kind.take() {
                ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(v)) => v,
                _ => panic!(),
            }
        } else {
            TensorSpecProto::new()
        }
    }

    // .tensorflow.TypeSpecProto type_spec_value = 34;


    pub fn get_type_spec_value(&self) -> &TypeSpecProto {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(ref v)) => v,
            _ => TypeSpecProto::default_instance(),
        }
    }
    pub fn clear_type_spec_value(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_type_spec_value(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_type_spec_value(&mut self, v: TypeSpecProto) {
        self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(v))
    }

    // Mutable pointer to the field.
    pub fn mut_type_spec_value(&mut self) -> &mut TypeSpecProto {
        if let ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(_)) = self.kind {
        } else {
            self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(TypeSpecProto::new()));
        }
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_type_spec_value(&mut self) -> TypeSpecProto {
        if self.has_type_spec_value() {
            match self.kind.take() {
                ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(v)) => v,
                _ => panic!(),
            }
        } else {
            TypeSpecProto::new()
        }
    }

    // .tensorflow.BoundedTensorSpecProto bounded_tensor_spec_value = 35;


    pub fn get_bounded_tensor_spec_value(&self) -> &BoundedTensorSpecProto {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(ref v)) => v,
            _ => BoundedTensorSpecProto::default_instance(),
        }
    }
    pub fn clear_bounded_tensor_spec_value(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_bounded_tensor_spec_value(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_bounded_tensor_spec_value(&mut self, v: BoundedTensorSpecProto) {
        self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(v))
    }

    // Mutable pointer to the field.
    pub fn mut_bounded_tensor_spec_value(&mut self) -> &mut BoundedTensorSpecProto {
        if let ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(_)) = self.kind {
        } else {
            self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(BoundedTensorSpecProto::new()));
        }
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_bounded_tensor_spec_value(&mut self) -> BoundedTensorSpecProto {
        if self.has_bounded_tensor_spec_value() {
            match self.kind.take() {
                ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(v)) => v,
                _ => panic!(),
            }
        } else {
            BoundedTensorSpecProto::new()
        }
    }

    // .tensorflow.ListValue list_value = 51;


    pub fn get_list_value(&self) -> &ListValue {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(ref v)) => v,
            _ => ListValue::default_instance(),
        }
    }
    pub fn clear_list_value(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_list_value(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_list_value(&mut self, v: ListValue) {
        self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(v))
    }

    // Mutable pointer to the field.
    pub fn mut_list_value(&mut self) -> &mut ListValue {
        if let ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(_)) = self.kind {
        } else {
            self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(ListValue::new()));
        }
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_list_value(&mut self) -> ListValue {
        if self.has_list_value() {
            match self.kind.take() {
                ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(v)) => v,
                _ => panic!(),
            }
        } else {
            ListValue::new()
        }
    }

    // .tensorflow.TupleValue tuple_value = 52;


    pub fn get_tuple_value(&self) -> &TupleValue {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(ref v)) => v,
            _ => TupleValue::default_instance(),
        }
    }
    pub fn clear_tuple_value(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_tuple_value(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_tuple_value(&mut self, v: TupleValue) {
        self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(v))
    }

    // Mutable pointer to the field.
    pub fn mut_tuple_value(&mut self) -> &mut TupleValue {
        if let ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(_)) = self.kind {
        } else {
            self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(TupleValue::new()));
        }
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_tuple_value(&mut self) -> TupleValue {
        if self.has_tuple_value() {
            match self.kind.take() {
                ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(v)) => v,
                _ => panic!(),
            }
        } else {
            TupleValue::new()
        }
    }

    // .tensorflow.DictValue dict_value = 53;


    pub fn get_dict_value(&self) -> &DictValue {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(ref v)) => v,
            _ => DictValue::default_instance(),
        }
    }
    pub fn clear_dict_value(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_dict_value(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_dict_value(&mut self, v: DictValue) {
        self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(v))
    }

    // Mutable pointer to the field.
    pub fn mut_dict_value(&mut self) -> &mut DictValue {
        if let ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(_)) = self.kind {
        } else {
            self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(DictValue::new()));
        }
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_dict_value(&mut self) -> DictValue {
        if self.has_dict_value() {
            match self.kind.take() {
                ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(v)) => v,
                _ => panic!(),
            }
        } else {
            DictValue::new()
        }
    }

    // .tensorflow.NamedTupleValue named_tuple_value = 54;


    pub fn get_named_tuple_value(&self) -> &NamedTupleValue {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(ref v)) => v,
            _ => NamedTupleValue::default_instance(),
        }
    }
    pub fn clear_named_tuple_value(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_named_tuple_value(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_named_tuple_value(&mut self, v: NamedTupleValue) {
        self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(v))
    }

    // Mutable pointer to the field.
    pub fn mut_named_tuple_value(&mut self) -> &mut NamedTupleValue {
        if let ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(_)) = self.kind {
        } else {
            self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(NamedTupleValue::new()));
        }
        match self.kind {
            ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_named_tuple_value(&mut self) -> NamedTupleValue {
        if self.has_named_tuple_value() {
            match self.kind.take() {
                ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(v)) => v,
                _ => panic!(),
            }
        } else {
            NamedTupleValue::new()
        }
    }
}

impl ::protobuf::Message for StructuredValue {
    fn is_initialized(&self) -> bool {
        if let Some(StructuredValue_oneof_kind::none_value(ref v)) = self.kind {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(StructuredValue_oneof_kind::tensor_shape_value(ref v)) = self.kind {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(StructuredValue_oneof_kind::tensor_spec_value(ref v)) = self.kind {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(StructuredValue_oneof_kind::type_spec_value(ref v)) = self.kind {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(ref v)) = self.kind {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(StructuredValue_oneof_kind::list_value(ref v)) = self.kind {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(StructuredValue_oneof_kind::tuple_value(ref v)) = self.kind {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(StructuredValue_oneof_kind::dict_value(ref v)) = self.kind {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(StructuredValue_oneof_kind::named_tuple_value(ref v)) = self.kind {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(is.read_message()?));
                },
                11 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::float64_value(is.read_double()?));
                },
                12 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::int64_value(is.read_sint64()?));
                },
                13 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::string_value(is.read_string()?));
                },
                14 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::bool_value(is.read_bool()?));
                },
                31 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(is.read_message()?));
                },
                32 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_dtype_value(is.read_enum()?));
                },
                33 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(is.read_message()?));
                },
                34 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(is.read_message()?));
                },
                35 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(is.read_message()?));
                },
                51 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(is.read_message()?));
                },
                52 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(is.read_message()?));
                },
                53 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(is.read_message()?));
                },
                54 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(is.read_message()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.kind {
            match v {
                &StructuredValue_oneof_kind::none_value(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &StructuredValue_oneof_kind::float64_value(v) => {
                    my_size += 9;
                },
                &StructuredValue_oneof_kind::int64_value(v) => {
                    my_size += ::protobuf::rt::value_varint_zigzag_size(12, v);
                },
                &StructuredValue_oneof_kind::string_value(ref v) => {
                    my_size += ::protobuf::rt::string_size(13, &v);
                },
                &StructuredValue_oneof_kind::bool_value(v) => {
                    my_size += 2;
                },
                &StructuredValue_oneof_kind::tensor_shape_value(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &StructuredValue_oneof_kind::tensor_dtype_value(v) => {
                    my_size += ::protobuf::rt::enum_size(32, v);
                },
                &StructuredValue_oneof_kind::tensor_spec_value(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &StructuredValue_oneof_kind::type_spec_value(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &StructuredValue_oneof_kind::bounded_tensor_spec_value(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &StructuredValue_oneof_kind::list_value(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &StructuredValue_oneof_kind::tuple_value(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &StructuredValue_oneof_kind::dict_value(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &StructuredValue_oneof_kind::named_tuple_value(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let ::std::option::Option::Some(ref v) = self.kind {
            match v {
                &StructuredValue_oneof_kind::none_value(ref v) => {
                    os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &StructuredValue_oneof_kind::float64_value(v) => {
                    os.write_double(11, v)?;
                },
                &StructuredValue_oneof_kind::int64_value(v) => {
                    os.write_sint64(12, v)?;
                },
                &StructuredValue_oneof_kind::string_value(ref v) => {
                    os.write_string(13, v)?;
                },
                &StructuredValue_oneof_kind::bool_value(v) => {
                    os.write_bool(14, v)?;
                },
                &StructuredValue_oneof_kind::tensor_shape_value(ref v) => {
                    os.write_tag(31, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &StructuredValue_oneof_kind::tensor_dtype_value(v) => {
                    os.write_enum(32, v.value())?;
                },
                &StructuredValue_oneof_kind::tensor_spec_value(ref v) => {
                    os.write_tag(33, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &StructuredValue_oneof_kind::type_spec_value(ref v) => {
                    os.write_tag(34, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &StructuredValue_oneof_kind::bounded_tensor_spec_value(ref v) => {
                    os.write_tag(35, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &StructuredValue_oneof_kind::list_value(ref v) => {
                    os.write_tag(51, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &StructuredValue_oneof_kind::tuple_value(ref v) => {
                    os.write_tag(52, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &StructuredValue_oneof_kind::dict_value(ref v) => {
                    os.write_tag(53, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &StructuredValue_oneof_kind::named_tuple_value(ref v) => {
                    os.write_tag(54, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
            };
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, NoneValue>(
                    "none_value",
                    StructuredValue::has_none_value,
                    StructuredValue::get_none_value,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_f64_accessor::<_>(
                    "float64_value",
                    StructuredValue::has_float64_value,
                    StructuredValue::get_float64_value,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_i64_accessor::<_>(
                    "int64_value",
                    StructuredValue::has_int64_value,
                    StructuredValue::get_int64_value,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
                    "string_value",
                    StructuredValue::has_string_value,
                    StructuredValue::get_string_value,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>(
                    "bool_value",
                    StructuredValue::has_bool_value,
                    StructuredValue::get_bool_value,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, super::tensor_shape::TensorShapeProto>(
                    "tensor_shape_value",
                    StructuredValue::has_tensor_shape_value,
                    StructuredValue::get_tensor_shape_value,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor::<_, super::types::DataType>(
                    "tensor_dtype_value",
                    StructuredValue::has_tensor_dtype_value,
                    StructuredValue::get_tensor_dtype_value,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TensorSpecProto>(
                    "tensor_spec_value",
                    StructuredValue::has_tensor_spec_value,
                    StructuredValue::get_tensor_spec_value,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TypeSpecProto>(
                    "type_spec_value",
                    StructuredValue::has_type_spec_value,
                    StructuredValue::get_type_spec_value,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, BoundedTensorSpecProto>(
                    "bounded_tensor_spec_value",
                    StructuredValue::has_bounded_tensor_spec_value,
                    StructuredValue::get_bounded_tensor_spec_value,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ListValue>(
                    "list_value",
                    StructuredValue::has_list_value,
                    StructuredValue::get_list_value,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TupleValue>(
                    "tuple_value",
                    StructuredValue::has_tuple_value,
                    StructuredValue::get_tuple_value,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, DictValue>(
                    "dict_value",
                    StructuredValue::has_dict_value,
                    StructuredValue::get_dict_value,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, NamedTupleValue>(
                    "named_tuple_value",
                    StructuredValue::has_named_tuple_value,
                    StructuredValue::get_named_tuple_value,
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<StructuredValue>(
                    "StructuredValue",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static StructuredValue {
        static mut instance: ::protobuf::lazy::Lazy<StructuredValue> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(StructuredValue::new)
        }
    }
}

impl ::protobuf::Clear for StructuredValue {
    fn clear(&mut self) {
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct NoneValue {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let fields = ::std::vec::Vec::new();
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<NoneValue>(
                    "NoneValue",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static NoneValue {
        static mut instance: ::protobuf::lazy::Lazy<NoneValue> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(NoneValue::new)
        }
    }
}

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

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

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

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

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

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

    // repeated .tensorflow.StructuredValue values = 1;


    pub fn get_values(&self) -> &[StructuredValue] {
        &self.values
    }
    pub fn clear_values(&mut self) {
        self.values.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<StructuredValue> {
        &mut self.values
    }

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

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

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

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

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

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<StructuredValue>>(
                    "values",
                    |m: &ListValue| { &m.values },
                    |m: &mut ListValue| { &mut m.values },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListValue>(
                    "ListValue",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static ListValue {
        static mut instance: ::protobuf::lazy::Lazy<ListValue> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(ListValue::new)
        }
    }
}

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

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

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

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

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

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

    // repeated .tensorflow.StructuredValue values = 1;


    pub fn get_values(&self) -> &[StructuredValue] {
        &self.values
    }
    pub fn clear_values(&mut self) {
        self.values.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<StructuredValue> {
        &mut self.values
    }

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

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

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

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

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

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<StructuredValue>>(
                    "values",
                    |m: &TupleValue| { &m.values },
                    |m: &mut TupleValue| { &mut m.values },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<TupleValue>(
                    "TupleValue",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TupleValue {
        static mut instance: ::protobuf::lazy::Lazy<TupleValue> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(TupleValue::new)
        }
    }
}

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct DictValue {
    // message fields
    pub fields: ::std::collections::HashMap<::std::string::String, StructuredValue>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .tensorflow.DictValue.FieldsEntry fields = 1;


    pub fn get_fields(&self) -> &::std::collections::HashMap<::std::string::String, StructuredValue> {
        &self.fields
    }
    pub fn clear_fields(&mut self) {
        self.fields.clear();
    }

    // Param is passed by value, moved
    pub fn set_fields(&mut self, v: ::std::collections::HashMap<::std::string::String, StructuredValue>) {
        self.fields = v;
    }

    // Mutable pointer to the field.
    pub fn mut_fields(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, StructuredValue> {
        &mut self.fields
    }

    // Take field
    pub fn take_fields(&mut self) -> ::std::collections::HashMap<::std::string::String, StructuredValue> {
        ::std::mem::replace(&mut self.fields, ::std::collections::HashMap::new())
    }
}

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

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

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<StructuredValue>>(1, &self.fields);
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<StructuredValue>>(1, &self.fields, os)?;
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<StructuredValue>>(
                    "fields",
                    |m: &DictValue| { &m.fields },
                    |m: &mut DictValue| { &mut m.fields },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<DictValue>(
                    "DictValue",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static DictValue {
        static mut instance: ::protobuf::lazy::Lazy<DictValue> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(DictValue::new)
        }
    }
}

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct PairValue {
    // message fields
    pub key: ::std::string::String,
    pub value: ::protobuf::SingularPtrField<StructuredValue>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string key = 1;


    pub fn get_key(&self) -> &str {
        &self.key
    }
    pub fn clear_key(&mut self) {
        self.key.clear();
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_key(&mut self) -> &mut ::std::string::String {
        &mut self.key
    }

    // Take field
    pub fn take_key(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.key, ::std::string::String::new())
    }

    // .tensorflow.StructuredValue value = 2;


    pub fn get_value(&self) -> &StructuredValue {
        self.value.as_ref().unwrap_or_else(|| StructuredValue::default_instance())
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

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

    // Param is passed by value, moved
    pub fn set_value(&mut self, v: StructuredValue) {
        self.value = ::protobuf::SingularPtrField::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 StructuredValue {
        if self.value.is_none() {
            self.value.set_default();
        }
        self.value.as_mut().unwrap()
    }

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.key.is_empty() {
            os.write_string(1, &self.key)?;
        }
        if let Some(ref v) = self.value.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "key",
                    |m: &PairValue| { &m.key },
                    |m: &mut PairValue| { &mut m.key },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<StructuredValue>>(
                    "value",
                    |m: &PairValue| { &m.value },
                    |m: &mut PairValue| { &mut m.value },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<PairValue>(
                    "PairValue",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static PairValue {
        static mut instance: ::protobuf::lazy::Lazy<PairValue> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(PairValue::new)
        }
    }
}

impl ::protobuf::Clear for PairValue {
    fn clear(&mut self) {
        self.key.clear();
        self.value.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct NamedTupleValue {
    // message fields
    pub name: ::std::string::String,
    pub values: ::protobuf::RepeatedField<PairValue>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = 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 {
        &mut self.name
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.name, ::std::string::String::new())
    }

    // repeated .tensorflow.PairValue values = 2;


    pub fn get_values(&self) -> &[PairValue] {
        &self.values
    }
    pub fn clear_values(&mut self) {
        self.values.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<PairValue> {
        &mut self.values
    }

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

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

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

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

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

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "name",
                    |m: &NamedTupleValue| { &m.name },
                    |m: &mut NamedTupleValue| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<PairValue>>(
                    "values",
                    |m: &NamedTupleValue| { &m.values },
                    |m: &mut NamedTupleValue| { &mut m.values },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<NamedTupleValue>(
                    "NamedTupleValue",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static NamedTupleValue {
        static mut instance: ::protobuf::lazy::Lazy<NamedTupleValue> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(NamedTupleValue::new)
        }
    }
}

impl ::protobuf::Clear for NamedTupleValue {
    fn clear(&mut self) {
        self.name.clear();
        self.values.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct TensorSpecProto {
    // message fields
    pub name: ::std::string::String,
    pub shape: ::protobuf::SingularPtrField<super::tensor_shape::TensorShapeProto>,
    pub dtype: super::types::DataType,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = 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 {
        &mut self.name
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.name, ::std::string::String::new())
    }

    // .tensorflow.TensorShapeProto shape = 2;


    pub fn get_shape(&self) -> &super::tensor_shape::TensorShapeProto {
        self.shape.as_ref().unwrap_or_else(|| super::tensor_shape::TensorShapeProto::default_instance())
    }
    pub fn clear_shape(&mut self) {
        self.shape.clear();
    }

    pub fn has_shape(&self) -> bool {
        self.shape.is_some()
    }

    // Param is passed by value, moved
    pub fn set_shape(&mut self, v: super::tensor_shape::TensorShapeProto) {
        self.shape = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_shape(&mut self) -> &mut super::tensor_shape::TensorShapeProto {
        if self.shape.is_none() {
            self.shape.set_default();
        }
        self.shape.as_mut().unwrap()
    }

    // Take field
    pub fn take_shape(&mut self) -> super::tensor_shape::TensorShapeProto {
        self.shape.take().unwrap_or_else(|| super::tensor_shape::TensorShapeProto::new())
    }

    // .tensorflow.DataType dtype = 3;


    pub fn get_dtype(&self) -> super::types::DataType {
        self.dtype
    }
    pub fn clear_dtype(&mut self) {
        self.dtype = super::types::DataType::DT_INVALID;
    }

    // Param is passed by value, moved
    pub fn set_dtype(&mut self, v: super::types::DataType) {
        self.dtype = v;
    }
}

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.shape)?;
                },
                3 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.dtype, 3, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if let Some(ref v) = self.shape.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if self.dtype != super::types::DataType::DT_INVALID {
            my_size += ::protobuf::rt::enum_size(3, self.dtype);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if let Some(ref v) = self.shape.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if self.dtype != super::types::DataType::DT_INVALID {
            os.write_enum(3, self.dtype.value())?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "name",
                    |m: &TensorSpecProto| { &m.name },
                    |m: &mut TensorSpecProto| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::tensor_shape::TensorShapeProto>>(
                    "shape",
                    |m: &TensorSpecProto| { &m.shape },
                    |m: &mut TensorSpecProto| { &mut m.shape },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::types::DataType>>(
                    "dtype",
                    |m: &TensorSpecProto| { &m.dtype },
                    |m: &mut TensorSpecProto| { &mut m.dtype },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<TensorSpecProto>(
                    "TensorSpecProto",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TensorSpecProto {
        static mut instance: ::protobuf::lazy::Lazy<TensorSpecProto> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(TensorSpecProto::new)
        }
    }
}

impl ::protobuf::Clear for TensorSpecProto {
    fn clear(&mut self) {
        self.name.clear();
        self.shape.clear();
        self.dtype = super::types::DataType::DT_INVALID;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct BoundedTensorSpecProto {
    // message fields
    pub name: ::std::string::String,
    pub shape: ::protobuf::SingularPtrField<super::tensor_shape::TensorShapeProto>,
    pub dtype: super::types::DataType,
    pub minimum: ::protobuf::SingularPtrField<super::tensor::TensorProto>,
    pub maximum: ::protobuf::SingularPtrField<super::tensor::TensorProto>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = 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 {
        &mut self.name
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.name, ::std::string::String::new())
    }

    // .tensorflow.TensorShapeProto shape = 2;


    pub fn get_shape(&self) -> &super::tensor_shape::TensorShapeProto {
        self.shape.as_ref().unwrap_or_else(|| super::tensor_shape::TensorShapeProto::default_instance())
    }
    pub fn clear_shape(&mut self) {
        self.shape.clear();
    }

    pub fn has_shape(&self) -> bool {
        self.shape.is_some()
    }

    // Param is passed by value, moved
    pub fn set_shape(&mut self, v: super::tensor_shape::TensorShapeProto) {
        self.shape = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_shape(&mut self) -> &mut super::tensor_shape::TensorShapeProto {
        if self.shape.is_none() {
            self.shape.set_default();
        }
        self.shape.as_mut().unwrap()
    }

    // Take field
    pub fn take_shape(&mut self) -> super::tensor_shape::TensorShapeProto {
        self.shape.take().unwrap_or_else(|| super::tensor_shape::TensorShapeProto::new())
    }

    // .tensorflow.DataType dtype = 3;


    pub fn get_dtype(&self) -> super::types::DataType {
        self.dtype
    }
    pub fn clear_dtype(&mut self) {
        self.dtype = super::types::DataType::DT_INVALID;
    }

    // Param is passed by value, moved
    pub fn set_dtype(&mut self, v: super::types::DataType) {
        self.dtype = v;
    }

    // .tensorflow.TensorProto minimum = 4;


    pub fn get_minimum(&self) -> &super::tensor::TensorProto {
        self.minimum.as_ref().unwrap_or_else(|| super::tensor::TensorProto::default_instance())
    }
    pub fn clear_minimum(&mut self) {
        self.minimum.clear();
    }

    pub fn has_minimum(&self) -> bool {
        self.minimum.is_some()
    }

    // Param is passed by value, moved
    pub fn set_minimum(&mut self, v: super::tensor::TensorProto) {
        self.minimum = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_minimum(&mut self) -> &mut super::tensor::TensorProto {
        if self.minimum.is_none() {
            self.minimum.set_default();
        }
        self.minimum.as_mut().unwrap()
    }

    // Take field
    pub fn take_minimum(&mut self) -> super::tensor::TensorProto {
        self.minimum.take().unwrap_or_else(|| super::tensor::TensorProto::new())
    }

    // .tensorflow.TensorProto maximum = 5;


    pub fn get_maximum(&self) -> &super::tensor::TensorProto {
        self.maximum.as_ref().unwrap_or_else(|| super::tensor::TensorProto::default_instance())
    }
    pub fn clear_maximum(&mut self) {
        self.maximum.clear();
    }

    pub fn has_maximum(&self) -> bool {
        self.maximum.is_some()
    }

    // Param is passed by value, moved
    pub fn set_maximum(&mut self, v: super::tensor::TensorProto) {
        self.maximum = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_maximum(&mut self) -> &mut super::tensor::TensorProto {
        if self.maximum.is_none() {
            self.maximum.set_default();
        }
        self.maximum.as_mut().unwrap()
    }

    // Take field
    pub fn take_maximum(&mut self) -> super::tensor::TensorProto {
        self.maximum.take().unwrap_or_else(|| super::tensor::TensorProto::new())
    }
}

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.shape)?;
                },
                3 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.dtype, 3, &mut self.unknown_fields)?
                },
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.minimum)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.maximum)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if let Some(ref v) = self.shape.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if self.dtype != super::types::DataType::DT_INVALID {
            my_size += ::protobuf::rt::enum_size(3, self.dtype);
        }
        if let Some(ref v) = self.minimum.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.maximum.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if let Some(ref v) = self.shape.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if self.dtype != super::types::DataType::DT_INVALID {
            os.write_enum(3, self.dtype.value())?;
        }
        if let Some(ref v) = self.minimum.as_ref() {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.maximum.as_ref() {
            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "name",
                    |m: &BoundedTensorSpecProto| { &m.name },
                    |m: &mut BoundedTensorSpecProto| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::tensor_shape::TensorShapeProto>>(
                    "shape",
                    |m: &BoundedTensorSpecProto| { &m.shape },
                    |m: &mut BoundedTensorSpecProto| { &mut m.shape },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::types::DataType>>(
                    "dtype",
                    |m: &BoundedTensorSpecProto| { &m.dtype },
                    |m: &mut BoundedTensorSpecProto| { &mut m.dtype },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::tensor::TensorProto>>(
                    "minimum",
                    |m: &BoundedTensorSpecProto| { &m.minimum },
                    |m: &mut BoundedTensorSpecProto| { &mut m.minimum },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::tensor::TensorProto>>(
                    "maximum",
                    |m: &BoundedTensorSpecProto| { &m.maximum },
                    |m: &mut BoundedTensorSpecProto| { &mut m.maximum },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<BoundedTensorSpecProto>(
                    "BoundedTensorSpecProto",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static BoundedTensorSpecProto {
        static mut instance: ::protobuf::lazy::Lazy<BoundedTensorSpecProto> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(BoundedTensorSpecProto::new)
        }
    }
}

impl ::protobuf::Clear for BoundedTensorSpecProto {
    fn clear(&mut self) {
        self.name.clear();
        self.shape.clear();
        self.dtype = super::types::DataType::DT_INVALID;
        self.minimum.clear();
        self.maximum.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct TypeSpecProto {
    // message fields
    pub type_spec_class: TypeSpecProto_TypeSpecClass,
    pub type_state: ::protobuf::SingularPtrField<StructuredValue>,
    pub type_spec_class_name: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .tensorflow.TypeSpecProto.TypeSpecClass type_spec_class = 1;


    pub fn get_type_spec_class(&self) -> TypeSpecProto_TypeSpecClass {
        self.type_spec_class
    }
    pub fn clear_type_spec_class(&mut self) {
        self.type_spec_class = TypeSpecProto_TypeSpecClass::UNKNOWN;
    }

    // Param is passed by value, moved
    pub fn set_type_spec_class(&mut self, v: TypeSpecProto_TypeSpecClass) {
        self.type_spec_class = v;
    }

    // .tensorflow.StructuredValue type_state = 2;


    pub fn get_type_state(&self) -> &StructuredValue {
        self.type_state.as_ref().unwrap_or_else(|| StructuredValue::default_instance())
    }
    pub fn clear_type_state(&mut self) {
        self.type_state.clear();
    }

    pub fn has_type_state(&self) -> bool {
        self.type_state.is_some()
    }

    // Param is passed by value, moved
    pub fn set_type_state(&mut self, v: StructuredValue) {
        self.type_state = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_type_state(&mut self) -> &mut StructuredValue {
        if self.type_state.is_none() {
            self.type_state.set_default();
        }
        self.type_state.as_mut().unwrap()
    }

    // Take field
    pub fn take_type_state(&mut self) -> StructuredValue {
        self.type_state.take().unwrap_or_else(|| StructuredValue::new())
    }

    // string type_spec_class_name = 3;


    pub fn get_type_spec_class_name(&self) -> &str {
        &self.type_spec_class_name
    }
    pub fn clear_type_spec_class_name(&mut self) {
        self.type_spec_class_name.clear();
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_type_spec_class_name(&mut self) -> &mut ::std::string::String {
        &mut self.type_spec_class_name
    }

    // Take field
    pub fn take_type_spec_class_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.type_spec_class_name, ::std::string::String::new())
    }
}

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.type_spec_class, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.type_state)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.type_spec_class_name)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.type_spec_class != TypeSpecProto_TypeSpecClass::UNKNOWN {
            my_size += ::protobuf::rt::enum_size(1, self.type_spec_class);
        }
        if let Some(ref v) = self.type_state.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if !self.type_spec_class_name.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.type_spec_class_name);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.type_spec_class != TypeSpecProto_TypeSpecClass::UNKNOWN {
            os.write_enum(1, self.type_spec_class.value())?;
        }
        if let Some(ref v) = self.type_state.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if !self.type_spec_class_name.is_empty() {
            os.write_string(3, &self.type_spec_class_name)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<TypeSpecProto_TypeSpecClass>>(
                    "type_spec_class",
                    |m: &TypeSpecProto| { &m.type_spec_class },
                    |m: &mut TypeSpecProto| { &mut m.type_spec_class },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<StructuredValue>>(
                    "type_state",
                    |m: &TypeSpecProto| { &m.type_state },
                    |m: &mut TypeSpecProto| { &mut m.type_state },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "type_spec_class_name",
                    |m: &TypeSpecProto| { &m.type_spec_class_name },
                    |m: &mut TypeSpecProto| { &mut m.type_spec_class_name },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<TypeSpecProto>(
                    "TypeSpecProto",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TypeSpecProto {
        static mut instance: ::protobuf::lazy::Lazy<TypeSpecProto> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(TypeSpecProto::new)
        }
    }
}

impl ::protobuf::Clear for TypeSpecProto {
    fn clear(&mut self) {
        self.type_spec_class = TypeSpecProto_TypeSpecClass::UNKNOWN;
        self.type_state.clear();
        self.type_spec_class_name.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum TypeSpecProto_TypeSpecClass {
    UNKNOWN = 0,
    SPARSE_TENSOR_SPEC = 1,
    INDEXED_SLICES_SPEC = 2,
    RAGGED_TENSOR_SPEC = 3,
    TENSOR_ARRAY_SPEC = 4,
    DATA_DATASET_SPEC = 5,
    DATA_ITERATOR_SPEC = 6,
    OPTIONAL_SPEC = 7,
    PER_REPLICA_SPEC = 8,
    VARIABLE_SPEC = 9,
    ROW_PARTITION_SPEC = 10,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<TypeSpecProto_TypeSpecClass> {
        match value {
            0 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::UNKNOWN),
            1 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::SPARSE_TENSOR_SPEC),
            2 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::INDEXED_SLICES_SPEC),
            3 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::RAGGED_TENSOR_SPEC),
            4 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::TENSOR_ARRAY_SPEC),
            5 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::DATA_DATASET_SPEC),
            6 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::DATA_ITERATOR_SPEC),
            7 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::OPTIONAL_SPEC),
            8 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::PER_REPLICA_SPEC),
            9 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::VARIABLE_SPEC),
            10 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::ROW_PARTITION_SPEC),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [TypeSpecProto_TypeSpecClass] = &[
            TypeSpecProto_TypeSpecClass::UNKNOWN,
            TypeSpecProto_TypeSpecClass::SPARSE_TENSOR_SPEC,
            TypeSpecProto_TypeSpecClass::INDEXED_SLICES_SPEC,
            TypeSpecProto_TypeSpecClass::RAGGED_TENSOR_SPEC,
            TypeSpecProto_TypeSpecClass::TENSOR_ARRAY_SPEC,
            TypeSpecProto_TypeSpecClass::DATA_DATASET_SPEC,
            TypeSpecProto_TypeSpecClass::DATA_ITERATOR_SPEC,
            TypeSpecProto_TypeSpecClass::OPTIONAL_SPEC,
            TypeSpecProto_TypeSpecClass::PER_REPLICA_SPEC,
            TypeSpecProto_TypeSpecClass::VARIABLE_SPEC,
            TypeSpecProto_TypeSpecClass::ROW_PARTITION_SPEC,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                ::protobuf::reflect::EnumDescriptor::new_pb_name::<TypeSpecProto_TypeSpecClass>("TypeSpecProto.TypeSpecClass", file_descriptor_proto())
            })
        }
    }
}

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

impl ::std::default::Default for TypeSpecProto_TypeSpecClass {
    fn default() -> Self {
        TypeSpecProto_TypeSpecClass::UNKNOWN
    }
}

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n%tensorflow/core/protobuf/struct.proto\x12\ntensorflow\x1a&tensorflow/\
    core/framework/tensor.proto\x1a,tensorflow/core/framework/tensor_shape.p\
    roto\x1a%tensorflow/core/framework/types.proto\"\xdc\x06\n\x0fStructured\
    Value\x126\n\nnone_value\x18\x01\x20\x01(\x0b2\x15.tensorflow.NoneValueH\
    \0R\tnoneValue\x12%\n\rfloat64_value\x18\x0b\x20\x01(\x01H\0R\x0cfloat64\
    Value\x12!\n\x0bint64_value\x18\x0c\x20\x01(\x12H\0R\nint64Value\x12#\n\
    \x0cstring_value\x18\r\x20\x01(\tH\0R\x0bstringValue\x12\x1f\n\nbool_val\
    ue\x18\x0e\x20\x01(\x08H\0R\tboolValue\x12L\n\x12tensor_shape_value\x18\
    \x1f\x20\x01(\x0b2\x1c.tensorflow.TensorShapeProtoH\0R\x10tensorShapeVal\
    ue\x12D\n\x12tensor_dtype_value\x18\x20\x20\x01(\x0e2\x14.tensorflow.Dat\
    aTypeH\0R\x10tensorDtypeValue\x12I\n\x11tensor_spec_value\x18!\x20\x01(\
    \x0b2\x1b.tensorflow.TensorSpecProtoH\0R\x0ftensorSpecValue\x12C\n\x0fty\
    pe_spec_value\x18\"\x20\x01(\x0b2\x19.tensorflow.TypeSpecProtoH\0R\rtype\
    SpecValue\x12_\n\x19bounded_tensor_spec_value\x18#\x20\x01(\x0b2\".tenso\
    rflow.BoundedTensorSpecProtoH\0R\x16boundedTensorSpecValue\x126\n\nlist_\
    value\x183\x20\x01(\x0b2\x15.tensorflow.ListValueH\0R\tlistValue\x129\n\
    \x0btuple_value\x184\x20\x01(\x0b2\x16.tensorflow.TupleValueH\0R\ntupleV\
    alue\x126\n\ndict_value\x185\x20\x01(\x0b2\x15.tensorflow.DictValueH\0R\
    \tdictValue\x12I\n\x11named_tuple_value\x186\x20\x01(\x0b2\x1b.tensorflo\
    w.NamedTupleValueH\0R\x0fnamedTupleValueB\x06\n\x04kind\"\x0b\n\tNoneVal\
    ue\"@\n\tListValue\x123\n\x06values\x18\x01\x20\x03(\x0b2\x1b.tensorflow\
    .StructuredValueR\x06values\"A\n\nTupleValue\x123\n\x06values\x18\x01\
    \x20\x03(\x0b2\x1b.tensorflow.StructuredValueR\x06values\"\x9e\x01\n\tDi\
    ctValue\x129\n\x06fields\x18\x01\x20\x03(\x0b2!.tensorflow.DictValue.Fie\
    ldsEntryR\x06fields\x1aV\n\x0bFieldsEntry\x12\x10\n\x03key\x18\x01\x20\
    \x01(\tR\x03key\x121\n\x05value\x18\x02\x20\x01(\x0b2\x1b.tensorflow.Str\
    ucturedValueR\x05value:\x028\x01\"P\n\tPairValue\x12\x10\n\x03key\x18\
    \x01\x20\x01(\tR\x03key\x121\n\x05value\x18\x02\x20\x01(\x0b2\x1b.tensor\
    flow.StructuredValueR\x05value\"T\n\x0fNamedTupleValue\x12\x12\n\x04name\
    \x18\x01\x20\x01(\tR\x04name\x12-\n\x06values\x18\x02\x20\x03(\x0b2\x15.\
    tensorflow.PairValueR\x06values\"\x85\x01\n\x0fTensorSpecProto\x12\x12\n\
    \x04name\x18\x01\x20\x01(\tR\x04name\x122\n\x05shape\x18\x02\x20\x01(\
    \x0b2\x1c.tensorflow.TensorShapeProtoR\x05shape\x12*\n\x05dtype\x18\x03\
    \x20\x01(\x0e2\x14.tensorflow.DataTypeR\x05dtype\"\xf2\x01\n\x16BoundedT\
    ensorSpecProto\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x122\n\x05s\
    hape\x18\x02\x20\x01(\x0b2\x1c.tensorflow.TensorShapeProtoR\x05shape\x12\
    *\n\x05dtype\x18\x03\x20\x01(\x0e2\x14.tensorflow.DataTypeR\x05dtype\x12\
    1\n\x07minimum\x18\x04\x20\x01(\x0b2\x17.tensorflow.TensorProtoR\x07mini\
    mum\x121\n\x07maximum\x18\x05\x20\x01(\x0b2\x17.tensorflow.TensorProtoR\
    \x07maximum\"\xcf\x03\n\rTypeSpecProto\x12O\n\x0ftype_spec_class\x18\x01\
    \x20\x01(\x0e2'.tensorflow.TypeSpecProto.TypeSpecClassR\rtypeSpecClass\
    \x12:\n\ntype_state\x18\x02\x20\x01(\x0b2\x1b.tensorflow.StructuredValue\
    R\ttypeState\x12/\n\x14type_spec_class_name\x18\x03\x20\x01(\tR\x11typeS\
    pecClassName\"\xff\x01\n\rTypeSpecClass\x12\x0b\n\x07UNKNOWN\x10\0\x12\
    \x16\n\x12SPARSE_TENSOR_SPEC\x10\x01\x12\x17\n\x13INDEXED_SLICES_SPEC\
    \x10\x02\x12\x16\n\x12RAGGED_TENSOR_SPEC\x10\x03\x12\x15\n\x11TENSOR_ARR\
    AY_SPEC\x10\x04\x12\x15\n\x11DATA_DATASET_SPEC\x10\x05\x12\x16\n\x12DATA\
    _ITERATOR_SPEC\x10\x06\x12\x11\n\rOPTIONAL_SPEC\x10\x07\x12\x14\n\x10PER\
    _REPLICA_SPEC\x10\x08\x12\x11\n\rVARIABLE_SPEC\x10\t\x12\x16\n\x12ROW_PA\
    RTITION_SPEC\x10\nBJZHgithub.com/tensorflow/tensorflow/tensorflow/go/cor\
    e/core_protos_go_protoJ\xa40\n\x07\x12\x05\0\0\x95\x01\x01\n\x08\n\x01\
    \x0c\x12\x03\0\0\x12\n\x08\n\x01\x02\x12\x03\x02\0\x13\n\t\n\x02\x03\0\
    \x12\x03\x04\00\n\t\n\x02\x03\x01\x12\x03\x05\06\n\t\n\x02\x03\x02\x12\
    \x03\x06\0/\n\x08\n\x01\x08\x12\x03\x08\0_\n\t\n\x02\x08\x0b\x12\x03\x08\
    \0_\n\x96\x0b\n\x02\x04\0\x12\x04\"\0K\x01\x1a\x89\x0b\x20`StructuredVal\
    ue`\x20represents\x20a\x20dynamically\x20typed\x20value\x20representing\
    \x20various\n\x20data\x20structures\x20that\x20are\x20inspired\x20by\x20\
    Python\x20data\x20structures\x20typically\x20used\x20in\n\x20TensorFlow\
    \x20functions\x20as\x20inputs\x20and\x20outputs.\n\n\x20For\x20example\
    \x20when\x20saving\x20a\x20Layer\x20there\x20may\x20be\x20a\x20`training\
    `\x20argument.\x20If\x20the\n\x20user\x20passes\x20a\x20boolean\x20True/\
    False,\x20that\x20switches\x20between\x20two\x20concrete\n\x20TensorFlow\
    \x20functions.\x20In\x20order\x20to\x20switch\x20between\x20them\x20in\
    \x20the\x20same\x20way\x20after\n\x20loading\x20the\x20SavedModel,\x20we\
    \x20need\x20to\x20represent\x20\"True\"\x20and\x20\"False\".\n\n\x20A\
    \x20more\x20advanced\x20example\x20might\x20be\x20a\x20function\x20which\
    \x20takes\x20a\x20list\x20of\n\x20dictionaries\x20mapping\x20from\x20str\
    ings\x20to\x20Tensors.\x20In\x20order\x20to\x20map\x20from\n\x20user-spe\
    cified\x20arguments\x20`[{\"a\":\x20tf.constant(1.)},\x20{\"q\":\x20tf.c\
    onstant(3.)}]`\n\x20after\x20load\x20to\x20the\x20right\x20saved\x20Tens\
    orFlow\x20function,\x20we\x20need\x20to\x20represent\x20the\n\x20nested\
    \x20structure\x20and\x20the\x20strings,\x20recording\x20that\x20we\x20ha\
    ve\x20a\x20trace\x20for\x20anything\n\x20matching\x20`[{\"a\":\x20tf.Ten\
    sorSpec(None,\x20tf.float32)},\x20{\"q\":\x20tf.TensorSpec([],\n\x20tf.f\
    loat64)}]`\x20as\x20an\x20example.\n\n\x20Likewise\x20functions\x20may\
    \x20return\x20nested\x20structures\x20of\x20Tensors,\x20for\x20example\n\
    \x20returning\x20a\x20dictionary\x20mapping\x20from\x20strings\x20to\x20\
    Tensors.\x20In\x20order\x20for\x20the\n\x20loaded\x20function\x20to\x20r\
    eturn\x20the\x20same\x20structure\x20we\x20need\x20to\x20serialize\x20it\
    .\n\n\x20This\x20is\x20an\x20ergonomic\x20aid\x20for\x20working\x20with\
    \x20loaded\x20SavedModels,\x20not\x20a\x20promise\n\x20to\x20serialize\
    \x20all\x20possible\x20function\x20signatures.\x20For\x20example\x20we\
    \x20do\x20not\x20expect\n\x20to\x20pickle\x20generic\x20Python\x20object\
    s,\x20and\x20ideally\x20we'd\x20stay\x20language-agnostic.\n\n\n\n\x03\
    \x04\0\x01\x12\x03\"\x08\x17\n\"\n\x04\x04\0\x08\0\x12\x04$\x02J\x03\x1a\
    \x14\x20The\x20kind\x20of\x20value.\n\n\x0c\n\x05\x04\0\x08\0\x01\x12\
    \x03$\x08\x0c\n\x1f\n\x04\x04\0\x02\0\x12\x03&\x04\x1d\x1a\x12\x20Repres\
    ents\x20None.\n\n\x0c\n\x05\x04\0\x02\0\x06\x12\x03&\x04\r\n\x0c\n\x05\
    \x04\0\x02\0\x01\x12\x03&\x0e\x18\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03&\
    \x1b\x1c\nU\n\x04\x04\0\x02\x01\x12\x03)\x04\x1e\x1aH\x20Represents\x20a\
    \x20double-precision\x20floating-point\x20value\x20(a\x20Python\x20`floa\
    t`).\n\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03)\x04\n\n\x0c\n\x05\x04\0\
    \x02\x01\x01\x12\x03)\x0b\x18\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03)\x1b\
    \x1d\n\x91\x01\n\x04\x04\0\x02\x02\x12\x03,\x04\x1c\x1a\x83\x01\x20Repre\
    sents\x20a\x20signed\x20integer\x20value,\x20limited\x20to\x2064\x20bits\
    .\n\x20Larger\x20values\x20from\x20Python's\x20arbitrary-precision\x20in\
    tegers\x20are\x20unsupported.\n\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03,\
    \x04\n\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03,\x0b\x16\n\x0c\n\x05\x04\0\
    \x02\x02\x03\x12\x03,\x19\x1b\n\x92\x03\n\x04\x04\0\x02\x03\x12\x033\x04\
    \x1d\x1a\x84\x03\x20Represents\x20a\x20string\x20of\x20Unicode\x20charac\
    ters\x20stored\x20in\x20a\x20Python\x20`str`.\n\x20In\x20Python\x203,\
    \x20this\x20is\x20exactly\x20what\x20type\x20`str`\x20is.\n\x20In\x20Pyt\
    hon\x202,\x20this\x20is\x20the\x20UTF-8\x20encoding\x20of\x20the\x20char\
    acters.\n\x20For\x20strings\x20with\x20ASCII\x20characters\x20only\x20(a\
    s\x20often\x20used\x20in\x20TensorFlow\x20code)\n\x20there\x20is\x20effe\
    ctively\x20no\x20difference\x20between\x20the\x20language\x20versions.\n\
    \x20The\x20obsolescent\x20`unicode`\x20type\x20of\x20Python\x202\x20is\
    \x20not\x20supported\x20here.\n\n\x0c\n\x05\x04\0\x02\x03\x05\x12\x033\
    \x04\n\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x033\x0b\x17\n\x0c\n\x05\x04\0\
    \x02\x03\x03\x12\x033\x1a\x1c\n*\n\x04\x04\0\x02\x04\x12\x035\x04\x19\
    \x1a\x1d\x20Represents\x20a\x20boolean\x20value.\n\n\x0c\n\x05\x04\0\x02\
    \x04\x05\x12\x035\x04\x08\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x035\t\x13\n\
    \x0c\n\x05\x04\0\x02\x04\x03\x12\x035\x16\x18\n(\n\x04\x04\0\x02\x05\x12\
    \x038\x048\x1a\x1b\x20Represents\x20a\x20TensorShape.\n\n\x0c\n\x05\x04\
    \0\x02\x05\x06\x12\x038\x04\x1f\n\x0c\n\x05\x04\0\x02\x05\x01\x12\x038\
    \x202\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x03857\n2\n\x04\x04\0\x02\x06\
    \x12\x03:\x040\x1a%\x20Represents\x20an\x20enum\x20value\x20for\x20dtype\
    .\n\n\x0c\n\x05\x04\0\x02\x06\x06\x12\x03:\x04\x17\n\x0c\n\x05\x04\0\x02\
    \x06\x01\x12\x03:\x18*\n\x0c\n\x05\x04\0\x02\x06\x03\x12\x03:-/\n4\n\x04\
    \x04\0\x02\x07\x12\x03<\x04+\x1a'\x20Represents\x20a\x20value\x20for\x20\
    tf.TensorSpec.\n\n\x0c\n\x05\x04\0\x02\x07\x06\x12\x03<\x04\x13\n\x0c\n\
    \x05\x04\0\x02\x07\x01\x12\x03<\x14%\n\x0c\n\x05\x04\0\x02\x07\x03\x12\
    \x03<(*\n2\n\x04\x04\0\x02\x08\x12\x03>\x04'\x1a%\x20Represents\x20a\x20\
    value\x20for\x20tf.TypeSpec.\n\n\x0c\n\x05\x04\0\x02\x08\x06\x12\x03>\
    \x04\x11\n\x0c\n\x05\x04\0\x02\x08\x01\x12\x03>\x12!\n\x0c\n\x05\x04\0\
    \x02\x08\x03\x12\x03>$&\n;\n\x04\x04\0\x02\t\x12\x03@\x04:\x1a.\x20Repre\
    sents\x20a\x20value\x20for\x20tf.BoundedTensorSpec.\n\n\x0c\n\x05\x04\0\
    \x02\t\x06\x12\x03@\x04\x1a\n\x0c\n\x05\x04\0\x02\t\x01\x12\x03@\x1b4\n\
    \x0c\n\x05\x04\0\x02\t\x03\x12\x03@79\n,\n\x04\x04\0\x02\n\x12\x03C\x04\
    \x1e\x1a\x1f\x20Represents\x20a\x20list\x20of\x20`Value`.\n\n\x0c\n\x05\
    \x04\0\x02\n\x06\x12\x03C\x04\r\n\x0c\n\x05\x04\0\x02\n\x01\x12\x03C\x0e\
    \x18\n\x0c\n\x05\x04\0\x02\n\x03\x12\x03C\x1b\x1d\n-\n\x04\x04\0\x02\x0b\
    \x12\x03E\x04\x20\x1a\x20\x20Represents\x20a\x20tuple\x20of\x20`Value`.\
    \n\n\x0c\n\x05\x04\0\x02\x0b\x06\x12\x03E\x04\x0e\n\x0c\n\x05\x04\0\x02\
    \x0b\x01\x12\x03E\x0f\x1a\n\x0c\n\x05\x04\0\x02\x0b\x03\x12\x03E\x1d\x1f\
    \n)\n\x04\x04\0\x02\x0c\x12\x03G\x04\x1e\x1a\x1c\x20Represents\x20a\x20d\
    ict\x20`Value`.\n\n\x0c\n\x05\x04\0\x02\x0c\x06\x12\x03G\x04\r\n\x0c\n\
    \x05\x04\0\x02\x0c\x01\x12\x03G\x0e\x18\n\x0c\n\x05\x04\0\x02\x0c\x03\
    \x12\x03G\x1b\x1d\n.\n\x04\x04\0\x02\r\x12\x03I\x04+\x1a!\x20Represents\
    \x20Python's\x20namedtuple.\n\n\x0c\n\x05\x04\0\x02\r\x06\x12\x03I\x04\
    \x13\n\x0c\n\x05\x04\0\x02\r\x01\x12\x03I\x14%\n\x0c\n\x05\x04\0\x02\r\
    \x03\x12\x03I(*\n\x1d\n\x02\x04\x01\x12\x03N\0\x14\x1a\x12\x20Represents\
    \x20None.\n\n\n\n\x03\x04\x01\x01\x12\x03N\x08\x11\n'\n\x02\x04\x02\x12\
    \x04Q\0S\x01\x1a\x1b\x20Represents\x20a\x20Python\x20list.\n\n\n\n\x03\
    \x04\x02\x01\x12\x03Q\x08\x11\n\x0b\n\x04\x04\x02\x02\0\x12\x03R\x02&\n\
    \x0c\n\x05\x04\x02\x02\0\x04\x12\x03R\x02\n\n\x0c\n\x05\x04\x02\x02\0\
    \x06\x12\x03R\x0b\x1a\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03R\x1b!\n\x0c\
    \n\x05\x04\x02\x02\0\x03\x12\x03R$%\n(\n\x02\x04\x03\x12\x04V\0X\x01\x1a\
    \x1c\x20Represents\x20a\x20Python\x20tuple.\n\n\n\n\x03\x04\x03\x01\x12\
    \x03V\x08\x12\n\x0b\n\x04\x04\x03\x02\0\x12\x03W\x02&\n\x0c\n\x05\x04\
    \x03\x02\0\x04\x12\x03W\x02\n\n\x0c\n\x05\x04\x03\x02\0\x06\x12\x03W\x0b\
    \x1a\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03W\x1b!\n\x0c\n\x05\x04\x03\x02\
    \0\x03\x12\x03W$%\n{\n\x02\x04\x04\x12\x04\\\0^\x01\x1ao\x20Represents\
    \x20a\x20Python\x20dict\x20keyed\x20by\x20`str`.\n\x20The\x20comment\x20\
    on\x20Unicode\x20from\x20Value.string_value\x20applies\x20analogously.\n\
    \n\n\n\x03\x04\x04\x01\x12\x03\\\x08\x11\n\x0b\n\x04\x04\x04\x02\0\x12\
    \x03]\x02*\n\x0c\n\x05\x04\x04\x02\0\x06\x12\x03]\x02\x1e\n\x0c\n\x05\
    \x04\x04\x02\0\x01\x12\x03]\x1f%\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03](\
    )\n-\n\x02\x04\x05\x12\x04a\0d\x01\x1a!\x20Represents\x20a\x20(key,\x20v\
    alue)\x20pair.\n\n\n\n\x03\x04\x05\x01\x12\x03a\x08\x11\n\x0b\n\x04\x04\
    \x05\x02\0\x12\x03b\x02\x11\n\x0c\n\x05\x04\x05\x02\0\x05\x12\x03b\x02\
    \x08\n\x0c\n\x05\x04\x05\x02\0\x01\x12\x03b\t\x0c\n\x0c\n\x05\x04\x05\
    \x02\0\x03\x12\x03b\x0f\x10\n\x0b\n\x04\x04\x05\x02\x01\x12\x03c\x02\x1c\
    \n\x0c\n\x05\x04\x05\x02\x01\x06\x12\x03c\x02\x11\n\x0c\n\x05\x04\x05\
    \x02\x01\x01\x12\x03c\x12\x17\n\x0c\n\x05\x04\x05\x02\x01\x03\x12\x03c\
    \x1a\x1b\n-\n\x02\x04\x06\x12\x04g\0j\x01\x1a!\x20Represents\x20Python's\
    \x20namedtuple.\n\n\n\n\x03\x04\x06\x01\x12\x03g\x08\x17\n\x0b\n\x04\x04\
    \x06\x02\0\x12\x03h\x02\x12\n\x0c\n\x05\x04\x06\x02\0\x05\x12\x03h\x02\
    \x08\n\x0c\n\x05\x04\x06\x02\0\x01\x12\x03h\t\r\n\x0c\n\x05\x04\x06\x02\
    \0\x03\x12\x03h\x10\x11\n\x0b\n\x04\x04\x06\x02\x01\x12\x03i\x02\x20\n\
    \x0c\n\x05\x04\x06\x02\x01\x04\x12\x03i\x02\n\n\x0c\n\x05\x04\x06\x02\
    \x01\x06\x12\x03i\x0b\x14\n\x0c\n\x05\x04\x06\x02\x01\x01\x12\x03i\x15\
    \x1b\n\x0c\n\x05\x04\x06\x02\x01\x03\x12\x03i\x1e\x1f\n4\n\x02\x04\x07\
    \x12\x04m\0q\x01\x1a(\x20A\x20protobuf\x20to\x20represent\x20tf.TensorSp\
    ec.\n\n\n\n\x03\x04\x07\x01\x12\x03m\x08\x17\n\x0b\n\x04\x04\x07\x02\0\
    \x12\x03n\x02\x12\n\x0c\n\x05\x04\x07\x02\0\x05\x12\x03n\x02\x08\n\x0c\n\
    \x05\x04\x07\x02\0\x01\x12\x03n\t\r\n\x0c\n\x05\x04\x07\x02\0\x03\x12\
    \x03n\x10\x11\n\x0b\n\x04\x04\x07\x02\x01\x12\x03o\x02(\n\x0c\n\x05\x04\
    \x07\x02\x01\x06\x12\x03o\x02\x1d\n\x0c\n\x05\x04\x07\x02\x01\x01\x12\
    \x03o\x1e#\n\x0c\n\x05\x04\x07\x02\x01\x03\x12\x03o&'\n\x0b\n\x04\x04\
    \x07\x02\x02\x12\x03p\x02\x20\n\x0c\n\x05\x04\x07\x02\x02\x06\x12\x03p\
    \x02\x15\n\x0c\n\x05\x04\x07\x02\x02\x01\x12\x03p\x16\x1b\n\x0c\n\x05\
    \x04\x07\x02\x02\x03\x12\x03p\x1e\x1f\n;\n\x02\x04\x08\x12\x04t\0z\x01\
    \x1a/\x20A\x20protobuf\x20to\x20represent\x20tf.BoundedTensorSpec.\n\n\n\
    \n\x03\x04\x08\x01\x12\x03t\x08\x1e\n\x0b\n\x04\x04\x08\x02\0\x12\x03u\
    \x02\x12\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x03u\x02\x08\n\x0c\n\x05\x04\
    \x08\x02\0\x01\x12\x03u\t\r\n\x0c\n\x05\x04\x08\x02\0\x03\x12\x03u\x10\
    \x11\n\x0b\n\x04\x04\x08\x02\x01\x12\x03v\x02(\n\x0c\n\x05\x04\x08\x02\
    \x01\x06\x12\x03v\x02\x1d\n\x0c\n\x05\x04\x08\x02\x01\x01\x12\x03v\x1e#\
    \n\x0c\n\x05\x04\x08\x02\x01\x03\x12\x03v&'\n\x0b\n\x04\x04\x08\x02\x02\
    \x12\x03w\x02\x20\n\x0c\n\x05\x04\x08\x02\x02\x06\x12\x03w\x02\x15\n\x0c\
    \n\x05\x04\x08\x02\x02\x01\x12\x03w\x16\x1b\n\x0c\n\x05\x04\x08\x02\x02\
    \x03\x12\x03w\x1e\x1f\n\x0b\n\x04\x04\x08\x02\x03\x12\x03x\x02%\n\x0c\n\
    \x05\x04\x08\x02\x03\x06\x12\x03x\x02\x18\n\x0c\n\x05\x04\x08\x02\x03\
    \x01\x12\x03x\x19\x20\n\x0c\n\x05\x04\x08\x02\x03\x03\x12\x03x#$\n\x0b\n\
    \x04\x04\x08\x02\x04\x12\x03y\x02%\n\x0c\n\x05\x04\x08\x02\x04\x06\x12\
    \x03y\x02\x18\n\x0c\n\x05\x04\x08\x02\x04\x01\x12\x03y\x19\x20\n\x0c\n\
    \x05\x04\x08\x02\x04\x03\x12\x03y#$\n'\n\x02\x04\t\x12\x05}\0\x95\x01\
    \x01\x1a\x1a\x20Represents\x20a\x20tf.TypeSpec\n\n\n\n\x03\x04\t\x01\x12\
    \x03}\x08\x15\n\r\n\x04\x04\t\x04\0\x12\x05~\x02\x8a\x01\x03\n\x0c\n\x05\
    \x04\t\x04\0\x01\x12\x03~\x07\x14\n\r\n\x06\x04\t\x04\0\x02\0\x12\x03\
    \x7f\x04\x10\n\x0e\n\x07\x04\t\x04\0\x02\0\x01\x12\x03\x7f\x04\x0b\n\x0e\
    \n\x07\x04\t\x04\0\x02\0\x02\x12\x03\x7f\x0e\x0f\n%\n\x06\x04\t\x04\0\
    \x02\x01\x12\x04\x80\x01\x04\x1b\"\x15\x20tf.SparseTensorSpec\n\n\x0f\n\
    \x07\x04\t\x04\0\x02\x01\x01\x12\x04\x80\x01\x04\x16\n\x0f\n\x07\x04\t\
    \x04\0\x02\x01\x02\x12\x04\x80\x01\x19\x1a\n&\n\x06\x04\t\x04\0\x02\x02\
    \x12\x04\x81\x01\x04\x1c\"\x16\x20tf.IndexedSlicesSpec\n\n\x0f\n\x07\x04\
    \t\x04\0\x02\x02\x01\x12\x04\x81\x01\x04\x17\n\x0f\n\x07\x04\t\x04\0\x02\
    \x02\x02\x12\x04\x81\x01\x1a\x1b\n%\n\x06\x04\t\x04\0\x02\x03\x12\x04\
    \x82\x01\x04\x1b\"\x15\x20tf.RaggedTensorSpec\n\n\x0f\n\x07\x04\t\x04\0\
    \x02\x03\x01\x12\x04\x82\x01\x04\x16\n\x0f\n\x07\x04\t\x04\0\x02\x03\x02\
    \x12\x04\x82\x01\x19\x1a\n$\n\x06\x04\t\x04\0\x02\x04\x12\x04\x83\x01\
    \x04\x1a\"\x14\x20tf.TensorArraySpec\n\n\x0f\n\x07\x04\t\x04\0\x02\x04\
    \x01\x12\x04\x83\x01\x04\x15\n\x0f\n\x07\x04\t\x04\0\x02\x04\x02\x12\x04\
    \x83\x01\x18\x19\n%\n\x06\x04\t\x04\0\x02\x05\x12\x04\x84\x01\x04\x1a\"\
    \x15\x20tf.data.DatasetSpec\n\n\x0f\n\x07\x04\t\x04\0\x02\x05\x01\x12\
    \x04\x84\x01\x04\x15\n\x0f\n\x07\x04\t\x04\0\x02\x05\x02\x12\x04\x84\x01\
    \x18\x19\n<\n\x06\x04\t\x04\0\x02\x06\x12\x04\x85\x01\x04\x1b\",\x20Iter\
    atorSpec\x20from\x20data/ops/iterator_ops.py\n\n\x0f\n\x07\x04\t\x04\0\
    \x02\x06\x01\x12\x04\x85\x01\x04\x16\n\x0f\n\x07\x04\t\x04\0\x02\x06\x02\
    \x12\x04\x85\x01\x19\x1a\n!\n\x06\x04\t\x04\0\x02\x07\x12\x04\x86\x01\
    \x04\x16\"\x11\x20tf.OptionalSpec\n\n\x0f\n\x07\x04\t\x04\0\x02\x07\x01\
    \x12\x04\x86\x01\x04\x11\n\x0f\n\x07\x04\t\x04\0\x02\x07\x02\x12\x04\x86\
    \x01\x14\x15\n:\n\x06\x04\t\x04\0\x02\x08\x12\x04\x87\x01\x04\x19\"*\x20\
    PerReplicaSpec\x20from\x20distribute/values.py\n\n\x0f\n\x07\x04\t\x04\0\
    \x02\x08\x01\x12\x04\x87\x01\x04\x14\n\x0f\n\x07\x04\t\x04\0\x02\x08\x02\
    \x12\x04\x87\x01\x17\x18\n!\n\x06\x04\t\x04\0\x02\t\x12\x04\x88\x01\x04\
    \x16\"\x11\x20tf.VariableSpec\n\n\x0f\n\x07\x04\t\x04\0\x02\t\x01\x12\
    \x04\x88\x01\x04\x11\n\x0f\n\x07\x04\t\x04\0\x02\t\x02\x12\x04\x88\x01\
    \x14\x15\n?\n\x06\x04\t\x04\0\x02\n\x12\x04\x89\x01\x04\x1c\"/\x20RowPar\
    titionSpec\x20from\x20ragged/row_partition.py\n\n\x0f\n\x07\x04\t\x04\0\
    \x02\n\x01\x12\x04\x89\x01\x04\x16\n\x0f\n\x07\x04\t\x04\0\x02\n\x02\x12\
    \x04\x89\x01\x19\x1b\n\x0c\n\x04\x04\t\x02\0\x12\x04\x8b\x01\x02$\n\r\n\
    \x05\x04\t\x02\0\x06\x12\x04\x8b\x01\x02\x0f\n\r\n\x05\x04\t\x02\0\x01\
    \x12\x04\x8b\x01\x10\x1f\n\r\n\x05\x04\t\x02\0\x03\x12\x04\x8b\x01\"#\n<\
    \n\x04\x04\t\x02\x01\x12\x04\x8e\x01\x02!\x1a.\x20The\x20value\x20return\
    ed\x20by\x20TypeSpec._serialize().\n\n\r\n\x05\x04\t\x02\x01\x06\x12\x04\
    \x8e\x01\x02\x11\n\r\n\x05\x04\t\x02\x01\x01\x12\x04\x8e\x01\x12\x1c\n\r\
    \n\x05\x04\t\x02\x01\x03\x12\x04\x8e\x01\x1f\x20\n\xb2\x02\n\x04\x04\t\
    \x02\x02\x12\x04\x94\x01\x02\"\x1a\xa3\x02\x20This\x20is\x20currently\
    \x20redundant\x20with\x20the\x20type_spec_class\x20enum,\x20and\x20is\
    \x20only\n\x20used\x20for\x20error\x20reporting.\x20\x20In\x20particular\
    ,\x20if\x20you\x20use\x20an\x20older\x20binary\x20to\n\x20load\x20a\x20n\
    ewer\x20model,\x20and\x20the\x20model\x20uses\x20a\x20TypeSpecClass\x20t\
    hat\x20the\x20older\n\x20binary\x20doesn't\x20support,\x20then\x20this\
    \x20lets\x20us\x20display\x20a\x20useful\x20error\x20message.\n\n\r\n\
    \x05\x04\t\x02\x02\x05\x12\x04\x94\x01\x02\x08\n\r\n\x05\x04\t\x02\x02\
    \x01\x12\x04\x94\x01\t\x1d\n\r\n\x05\x04\t\x02\x02\x03\x12\x04\x94\x01\
    \x20!b\x06proto3\
";

static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT;

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

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