/// <summary>Holder for reflection information generated from tensorflow/core/protobuf/struct.proto</summary>

public static partial class StructReflection {

#region Descriptor

/// <summary>File descriptor for tensorflow/core/protobuf/struct.proto</summary>

public static pbr::FileDescriptor Descriptor {

get { return descriptor; }

}

private static pbr::FileDescriptor descriptor;

static StructReflection() {

byte[] descriptorData = global::System.Convert.FromBase64String(

string.Concat(

"CiV0ZW5zb3JmbG93L2NvcmUvcHJvdG9idWYvc3RydWN0LnByb3RvEgp0ZW5z",

"b3JmbG93GiZ0ZW5zb3JmbG93L2NvcmUvZnJhbWV3b3JrL3RlbnNvci5wcm90",

"bxosdGVuc29yZmxvdy9jb3JlL2ZyYW1ld29yay90ZW5zb3Jfc2hhcGUucHJv",

"dG8aJXRlbnNvcmZsb3cvY29yZS9mcmFtZXdvcmsvdHlwZXMucHJvdG8ikAUK",

"D1N0cnVjdHVyZWRWYWx1ZRIrCgpub25lX3ZhbHVlGAEgASgLMhUudGVuc29y",

"Zmxvdy5Ob25lVmFsdWVIABIXCg1mbG9hdDY0X3ZhbHVlGAsgASgBSAASFQoL",

"aW50NjRfdmFsdWUYDCABKBJIABIWCgxzdHJpbmdfdmFsdWUYDSABKAlIABIU",

"Cgpib29sX3ZhbHVlGA4gASgISAASOgoSdGVuc29yX3NoYXBlX3ZhbHVlGB8g",

"ASgLMhwudGVuc29yZmxvdy5UZW5zb3JTaGFwZVByb3RvSAASMgoSdGVuc29y",

"X2R0eXBlX3ZhbHVlGCAgASgOMhQudGVuc29yZmxvdy5EYXRhVHlwZUgAEjgK",

"EXRlbnNvcl9zcGVjX3ZhbHVlGCEgASgLMhsudGVuc29yZmxvdy5UZW5zb3JT",

"cGVjUHJvdG9IABI0Cg90eXBlX3NwZWNfdmFsdWUYIiABKAsyGS50ZW5zb3Jm",

"bG93LlR5cGVTcGVjUHJvdG9IABJHChlib3VuZGVkX3RlbnNvcl9zcGVjX3Zh",

"bHVlGCMgASgLMiIudGVuc29yZmxvdy5Cb3VuZGVkVGVuc29yU3BlY1Byb3Rv",

"SAASKwoKbGlzdF92YWx1ZRgzIAEoCzIVLnRlbnNvcmZsb3cuTGlzdFZhbHVl",

"SAASLQoLdHVwbGVfdmFsdWUYNCABKAsyFi50ZW5zb3JmbG93LlR1cGxlVmFs",

"dWVIABIrCgpkaWN0X3ZhbHVlGDUgASgLMhUudGVuc29yZmxvdy5EaWN0VmFs",

"dWVIABI4ChFuYW1lZF90dXBsZV92YWx1ZRg2IAEoCzIbLnRlbnNvcmZsb3cu",

"TmFtZWRUdXBsZVZhbHVlSABCBgoEa2luZCILCglOb25lVmFsdWUiOAoJTGlz",

"dFZhbHVlEisKBnZhbHVlcxgBIAMoCzIbLnRlbnNvcmZsb3cuU3RydWN0dXJl",

"ZFZhbHVlIjkKClR1cGxlVmFsdWUSKwoGdmFsdWVzGAEgAygLMhsudGVuc29y",

"Zmxvdy5TdHJ1Y3R1cmVkVmFsdWUiigEKCURpY3RWYWx1ZRIxCgZmaWVsZHMY",

"ASADKAsyIS50ZW5zb3JmbG93LkRpY3RWYWx1ZS5GaWVsZHNFbnRyeRpKCgtG",

"aWVsZHNFbnRyeRILCgNrZXkYASABKAkSKgoFdmFsdWUYAiABKAsyGy50ZW5z",

"b3JmbG93LlN0cnVjdHVyZWRWYWx1ZToCOAEiRAoJUGFpclZhbHVlEgsKA2tl",

"eRgBIAEoCRIqCgV2YWx1ZRgCIAEoCzIbLnRlbnNvcmZsb3cuU3RydWN0dXJl",

"ZFZhbHVlIkYKD05hbWVkVHVwbGVWYWx1ZRIMCgRuYW1lGAEgASgJEiUKBnZh",

"bHVlcxgCIAMoCzIVLnRlbnNvcmZsb3cuUGFpclZhbHVlInEKD1RlbnNvclNw",

"ZWNQcm90bxIMCgRuYW1lGAEgASgJEisKBXNoYXBlGAIgASgLMhwudGVuc29y",

"Zmxvdy5UZW5zb3JTaGFwZVByb3RvEiMKBWR0eXBlGAMgASgOMhQudGVuc29y",

"Zmxvdy5EYXRhVHlwZSLMAQoWQm91bmRlZFRlbnNvclNwZWNQcm90bxIMCgRu",

"YW1lGAEgASgJEisKBXNoYXBlGAIgASgLMhwudGVuc29yZmxvdy5UZW5zb3JT",

"aGFwZVByb3RvEiMKBWR0eXBlGAMgASgOMhQudGVuc29yZmxvdy5EYXRhVHlw",

"ZRIoCgdtaW5pbXVtGAQgASgLMhcudGVuc29yZmxvdy5UZW5zb3JQcm90bxIo",

"CgdtYXhpbXVtGAUgASgLMhcudGVuc29yZmxvdy5UZW5zb3JQcm90byL4AwoN",

"VHlwZVNwZWNQcm90bxJACg90eXBlX3NwZWNfY2xhc3MYASABKA4yJy50ZW5z",

"b3JmbG93LlR5cGVTcGVjUHJvdG8uVHlwZVNwZWNDbGFzcxIvCgp0eXBlX3N0",

"YXRlGAIgASgLMhsudGVuc29yZmxvdy5TdHJ1Y3R1cmVkVmFsdWUSHAoUdHlw",

"ZV9zcGVjX2NsYXNzX25hbWUYAyABKAkSGwoTbnVtX2ZsYXRfY29tcG9uZW50",

"cxgEIAEoBSK4AgoNVHlwZVNwZWNDbGFzcxILCgdVTktOT1dOEAASFgoSU1BB",

"UlNFX1RFTlNPUl9TUEVDEAESFwoTSU5ERVhFRF9TTElDRVNfU1BFQxACEhYK",

"ElJBR0dFRF9URU5TT1JfU1BFQxADEhUKEVRFTlNPUl9BUlJBWV9TUEVDEAQS",

"FQoRREFUQV9EQVRBU0VUX1NQRUMQBRIWChJEQVRBX0lURVJBVE9SX1NQRUMQ",

"BhIRCg1PUFRJT05BTF9TUEVDEAcSFAoQUEVSX1JFUExJQ0FfU1BFQxAIEhEK",

"DVZBUklBQkxFX1NQRUMQCRIWChJST1dfUEFSVElUSU9OX1NQRUMQChIYChRS",

"RUdJU1RFUkVEX1RZUEVfU1BFQxAMEhcKE0VYVEVOU0lPTl9UWVBFX1NQRUMQ",

"DSIECAsQC0JXWlVnaXRodWIuY29tL3RlbnNvcmZsb3cvdGVuc29yZmxvdy90",

"ZW5zb3JmbG93L2dvL2NvcmUvcHJvdG9idWYvZm9yX2NvcmVfcHJvdG9zX2dv",

"X3Byb3RvYgZwcm90bzM="));

descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,

new pbr::FileDescriptor[] { global::Tensorflow.TensorReflection.Descriptor, global::Tensorflow.TensorShapeReflection.Descriptor, global::Tensorflow.TypesReflection.Descriptor, },

new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {

new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.StructuredValue), global::Tensorflow.StructuredValue.Parser, new[]{ "NoneValue", "Float64Value", "Int64Value", "StringValue", "BoolValue", "TensorShapeValue", "TensorDtypeValue", "TensorSpecValue", "TypeSpecValue", "BoundedTensorSpecValue", "ListValue", "TupleValue", "DictValue", "NamedTupleValue" }, new[]{ "Kind" }, null, null, null),

new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.NoneValue), global::Tensorflow.NoneValue.Parser, null, null, null, null, null),

new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.ListValue), global::Tensorflow.ListValue.Parser, new[]{ "Values" }, null, null, null, null),

new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.TupleValue), global::Tensorflow.TupleValue.Parser, new[]{ "Values" }, null, null, null, null),

new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.DictValue), global::Tensorflow.DictValue.Parser, new[]{ "Fields" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }),

new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.PairValue), global::Tensorflow.PairValue.Parser, new[]{ "Key", "Value" }, null, null, null, null),

new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.NamedTupleValue), global::Tensorflow.NamedTupleValue.Parser, new[]{ "Name", "Values" }, null, null, null, null),

new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.TensorSpecProto), global::Tensorflow.TensorSpecProto.Parser, new[]{ "Name", "Shape", "Dtype" }, null, null, null, null),

new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.BoundedTensorSpecProto), global::Tensorflow.BoundedTensorSpecProto.Parser, new[]{ "Name", "Shape", "Dtype", "Minimum", "Maximum" }, null, null, null, null),

new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.TypeSpecProto), global::Tensorflow.TypeSpecProto.Parser, new[]{ "TypeSpecClass", "TypeState", "TypeSpecClassName", "NumFlatComponents" }, null, new[]{ typeof(global::Tensorflow.TypeSpecProto.Types.TypeSpecClass) }, null, null)

}));

}

#endregion

}

#region Messages

/// <summary>

/// `StructuredValue` represents a dynamically typed value representing various

/// data structures that are inspired by Python data structures typically used in

/// TensorFlow functions as inputs and outputs.

///

/// For example when saving a Layer there may be a `training` argument. If the

/// user passes a boolean True/False, that switches between two concrete

/// TensorFlow functions. In order to switch between them in the same way after

/// loading the SavedModel, we need to represent "True" and "False".

///

/// A more advanced example might be a function which takes a list of

/// dictionaries mapping from strings to Tensors. In order to map from

/// user-specified arguments `[{"a": tf.constant(1.)}, {"q": tf.constant(3.)}]`

/// after load to the right saved TensorFlow function, we need to represent the

/// nested structure and the strings, recording that we have a trace for anything

/// matching `[{"a": tf.TensorSpec(None, tf.float32)}, {"q": tf.TensorSpec([],

/// tf.float64)}]` as an example.

///

/// Likewise functions may return nested structures of Tensors, for example

/// returning a dictionary mapping from strings to Tensors. In order for the

/// loaded function to return the same structure we need to serialize it.

///

/// This is an ergonomic aid for working with loaded SavedModels, not a promise

/// to serialize all possible function signatures. For example we do not expect

/// to pickle generic Python objects, and ideally we'd stay language-agnostic.

/// </summary>

public sealed partial class StructuredValue : pb::IMessage<StructuredValue>

#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

, pb::IBufferMessage

#endif

{

private static readonly pb::MessageParser<StructuredValue> _parser = new pb::MessageParser<StructuredValue>(() => new StructuredValue());

private pb::UnknownFieldSet _unknownFields;

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public static pb::MessageParser<StructuredValue> Parser { get { return _parser; } }

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public static pbr::MessageDescriptor Descriptor {

get { return global::Tensorflow.StructReflection.Descriptor.MessageTypes[0]; }

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

pbr::MessageDescriptor pb::IMessage.Descriptor {

get { return Descriptor; }

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public StructuredValue() {

OnConstruction();

}

partial void OnConstruction();

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public StructuredValue(StructuredValue other) : this() {

switch (other.KindCase) {

case KindOneofCase.NoneValue:

NoneValue = other.NoneValue.Clone();

break;

case KindOneofCase.Float64Value:

Float64Value = other.Float64Value;

break;

case KindOneofCase.Int64Value:

Int64Value = other.Int64Value;

break;

case KindOneofCase.StringValue:

StringValue = other.StringValue;

break;

case KindOneofCase.BoolValue:

BoolValue = other.BoolValue;

break;

case KindOneofCase.TensorShapeValue:

TensorShapeValue = other.TensorShapeValue.Clone();

break;

case KindOneofCase.TensorDtypeValue:

TensorDtypeValue = other.TensorDtypeValue;

break;

case KindOneofCase.TensorSpecValue:

TensorSpecValue = other.TensorSpecValue.Clone();

break;

case KindOneofCase.TypeSpecValue:

TypeSpecValue = other.TypeSpecValue.Clone();

break;

case KindOneofCase.BoundedTensorSpecValue:

BoundedTensorSpecValue = other.BoundedTensorSpecValue.Clone();

break;

case KindOneofCase.ListValue:

ListValue = other.ListValue.Clone();

break;

case KindOneofCase.TupleValue:

TupleValue = other.TupleValue.Clone();

break;

case KindOneofCase.DictValue:

DictValue = other.DictValue.Clone();

break;

case KindOneofCase.NamedTupleValue:

NamedTupleValue = other.NamedTupleValue.Clone();

break;

}

_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public StructuredValue Clone() {

return new StructuredValue(this);

}

/// <summary>Field number for the "none_value" field.</summary>

public const int NoneValueFieldNumber = 1;

/// <summary>

/// Represents None.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public global::Tensorflow.NoneValue NoneValue {

get { return kindCase_ == KindOneofCase.NoneValue ? (global::Tensorflow.NoneValue) kind_ : null; }

set {

kind_ = value;

kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.NoneValue;

}

}

/// <summary>Field number for the "float64_value" field.</summary>

public const int Float64ValueFieldNumber = 11;

/// <summary>

/// Represents a double-precision floating-point value (a Python `float`).

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public double Float64Value {

get { return kindCase_ == KindOneofCase.Float64Value ? (double) kind_ : 0D; }

set {

kind_ = value;

kindCase_ = KindOneofCase.Float64Value;

}

}

/// <summary>Field number for the "int64_value" field.</summary>

public const int Int64ValueFieldNumber = 12;

/// <summary>

/// Represents a signed integer value, limited to 64 bits.

/// Larger values from Python's arbitrary-precision integers are unsupported.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public long Int64Value {

get { return kindCase_ == KindOneofCase.Int64Value ? (long) kind_ : 0L; }

set {

kind_ = value;

kindCase_ = KindOneofCase.Int64Value;

}

}

/// <summary>Field number for the "string_value" field.</summary>

public const int StringValueFieldNumber = 13;

/// <summary>

/// Represents a string of Unicode characters stored in a Python `str`.

/// In Python 3, this is exactly what type `str` is.

/// In Python 2, this is the UTF-8 encoding of the characters.

/// For strings with ASCII characters only (as often used in TensorFlow code)

/// there is effectively no difference between the language versions.

/// The obsolescent `unicode` type of Python 2 is not supported here.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public string StringValue {

get { return kindCase_ == KindOneofCase.StringValue ? (string) kind_ : ""; }

set {

kind_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

kindCase_ = KindOneofCase.StringValue;

}

}

/// <summary>Field number for the "bool_value" field.</summary>

public const int BoolValueFieldNumber = 14;

/// <summary>

/// Represents a boolean value.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public bool BoolValue {

get { return kindCase_ == KindOneofCase.BoolValue ? (bool) kind_ : false; }

set {

kind_ = value;

kindCase_ = KindOneofCase.BoolValue;

}

}

/// <summary>Field number for the "tensor_shape_value" field.</summary>

public const int TensorShapeValueFieldNumber = 31;

/// <summary>

/// Represents a TensorShape.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public global::Tensorflow.TensorShapeProto TensorShapeValue {

get { return kindCase_ == KindOneofCase.TensorShapeValue ? (global::Tensorflow.TensorShapeProto) kind_ : null; }

set {

kind_ = value;

kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.TensorShapeValue;

}

}

/// <summary>Field number for the "tensor_dtype_value" field.</summary>

public const int TensorDtypeValueFieldNumber = 32;

/// <summary>

/// Represents an enum value for dtype.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public global::Tensorflow.DataType TensorDtypeValue {

get { return kindCase_ == KindOneofCase.TensorDtypeValue ? (global::Tensorflow.DataType) kind_ : global::Tensorflow.DataType.DtInvalid; }

set {

kind_ = value;

kindCase_ = KindOneofCase.TensorDtypeValue;

}

}

/// <summary>Field number for the "tensor_spec_value" field.</summary>

public const int TensorSpecValueFieldNumber = 33;

/// <summary>

/// Represents a value for tf.TensorSpec.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public global::Tensorflow.TensorSpecProto TensorSpecValue {

get { return kindCase_ == KindOneofCase.TensorSpecValue ? (global::Tensorflow.TensorSpecProto) kind_ : null; }

set {

kind_ = value;

kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.TensorSpecValue;

}

}

/// <summary>Field number for the "type_spec_value" field.</summary>

public const int TypeSpecValueFieldNumber = 34;

/// <summary>

/// Represents a value for tf.TypeSpec.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public global::Tensorflow.TypeSpecProto TypeSpecValue {

get { return kindCase_ == KindOneofCase.TypeSpecValue ? (global::Tensorflow.TypeSpecProto) kind_ : null; }

set {

kind_ = value;

kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.TypeSpecValue;

}

}

/// <summary>Field number for the "bounded_tensor_spec_value" field.</summary>

public const int BoundedTensorSpecValueFieldNumber = 35;

/// <summary>

/// Represents a value for tf.BoundedTensorSpec.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public global::Tensorflow.BoundedTensorSpecProto BoundedTensorSpecValue {

get { return kindCase_ == KindOneofCase.BoundedTensorSpecValue ? (global::Tensorflow.BoundedTensorSpecProto) kind_ : null; }

set {

kind_ = value;

kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.BoundedTensorSpecValue;

}

}

/// <summary>Field number for the "list_value" field.</summary>

public const int ListValueFieldNumber = 51;

/// <summary>

/// Represents a list of `Value`.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public global::Tensorflow.ListValue ListValue {

get { return kindCase_ == KindOneofCase.ListValue ? (global::Tensorflow.ListValue) kind_ : null; }

set {

kind_ = value;

kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.ListValue;

}

}

/// <summary>Field number for the "tuple_value" field.</summary>

public const int TupleValueFieldNumber = 52;

/// <summary>

/// Represents a tuple of `Value`.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public global::Tensorflow.TupleValue TupleValue {

get { return kindCase_ == KindOneofCase.TupleValue ? (global::Tensorflow.TupleValue) kind_ : null; }

set {

kind_ = value;

kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.TupleValue;

}

}

/// <summary>Field number for the "dict_value" field.</summary>

public const int DictValueFieldNumber = 53;

/// <summary>

/// Represents a dict `Value`.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public global::Tensorflow.DictValue DictValue {

get { return kindCase_ == KindOneofCase.DictValue ? (global::Tensorflow.DictValue) kind_ : null; }

set {

kind_ = value;

kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.DictValue;

}

}

/// <summary>Field number for the "named_tuple_value" field.</summary>

public const int NamedTupleValueFieldNumber = 54;

/// <summary>

/// Represents Python's namedtuple.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public global::Tensorflow.NamedTupleValue NamedTupleValue {

get { return kindCase_ == KindOneofCase.NamedTupleValue ? (global::Tensorflow.NamedTupleValue) kind_ : null; }

set {

kind_ = value;

kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.NamedTupleValue;

}

}

private object kind_;

/// <summary>Enum of possible cases for the "kind" oneof.</summary>

public enum KindOneofCase {

None = 0,

NoneValue = 1,

Float64Value = 11,

Int64Value = 12,

StringValue = 13,

BoolValue = 14,

TensorShapeValue = 31,

TensorDtypeValue = 32,

TensorSpecValue = 33,

TypeSpecValue = 34,

BoundedTensorSpecValue = 35,

ListValue = 51,

TupleValue = 52,

DictValue = 53,

NamedTupleValue = 54,

}

private KindOneofCase kindCase_ = KindOneofCase.None;

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public KindOneofCase KindCase {

get { return kindCase_; }

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public void ClearKind() {

kindCase_ = KindOneofCase.None;

kind_ = null;

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public override bool Equals(object other) {

return Equals(other as StructuredValue);

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public bool Equals(StructuredValue other) {

if (ReferenceEquals(other, null)) {

return false;

}

if (ReferenceEquals(other, this)) {

return true;

}

if (!object.Equals(NoneValue, other.NoneValue)) return false;

if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Float64Value, other.Float64Value)) return false;

if (Int64Value != other.Int64Value) return false;

if (StringValue != other.StringValue) return false;

if (BoolValue != other.BoolValue) return false;

if (!object.Equals(TensorShapeValue, other.TensorShapeValue)) return false;

if (TensorDtypeValue != other.TensorDtypeValue) return false;

if (!object.Equals(TensorSpecValue, other.TensorSpecValue)) return false;

if (!object.Equals(TypeSpecValue, other.TypeSpecValue)) return false;

if (!object.Equals(BoundedTensorSpecValue, other.BoundedTensorSpecValue)) return false;

if (!object.Equals(ListValue, other.ListValue)) return false;

if (!object.Equals(TupleValue, other.TupleValue)) return false;

if (!object.Equals(DictValue, other.DictValue)) return false;

if (!object.Equals(NamedTupleValue, other.NamedTupleValue)) return false;

if (KindCase != other.KindCase) return false;

return Equals(_unknownFields, other._unknownFields);

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public override int GetHashCode() {

int hash = 1;

if (kindCase_ == KindOneofCase.NoneValue) hash ^= NoneValue.GetHashCode();

if (kindCase_ == KindOneofCase.Float64Value) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Float64Value);

if (kindCase_ == KindOneofCase.Int64Value) hash ^= Int64Value.GetHashCode();

if (kindCase_ == KindOneofCase.StringValue) hash ^= StringValue.GetHashCode();

if (kindCase_ == KindOneofCase.BoolValue) hash ^= BoolValue.GetHashCode();

if (kindCase_ == KindOneofCase.TensorShapeValue) hash ^= TensorShapeValue.GetHashCode();

if (kindCase_ == KindOneofCase.TensorDtypeValue) hash ^= TensorDtypeValue.GetHashCode();

if (kindCase_ == KindOneofCase.TensorSpecValue) hash ^= TensorSpecValue.GetHashCode();

if (kindCase_ == KindOneofCase.TypeSpecValue) hash ^= TypeSpecValue.GetHashCode();

if (kindCase_ == KindOneofCase.BoundedTensorSpecValue) hash ^= BoundedTensorSpecValue.GetHashCode();

if (kindCase_ == KindOneofCase.ListValue) hash ^= ListValue.GetHashCode();

if (kindCase_ == KindOneofCase.TupleValue) hash ^= TupleValue.GetHashCode();

if (kindCase_ == KindOneofCase.DictValue) hash ^= DictValue.GetHashCode();

if (kindCase_ == KindOneofCase.NamedTupleValue) hash ^= NamedTupleValue.GetHashCode();

hash ^= (int) kindCase_;

if (_unknownFields != null) {

hash ^= _unknownFields.GetHashCode();

}

return hash;

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public override string ToString() {

return pb::JsonFormatter.ToDiagnosticString(this);

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public void WriteTo(pb::CodedOutputStream output) {

#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

output.WriteRawMessage(this);

#else

if (kindCase_ == KindOneofCase.NoneValue) {

output.WriteRawTag(10);

output.WriteMessage(NoneValue);

}

if (kindCase_ == KindOneofCase.Float64Value) {

output.WriteRawTag(89);

output.WriteDouble(Float64Value);

}

if (kindCase_ == KindOneofCase.Int64Value) {

output.WriteRawTag(96);

output.WriteSInt64(Int64Value);

}

if (kindCase_ == KindOneofCase.StringValue) {

output.WriteRawTag(106);

output.WriteString(StringValue);

}

if (kindCase_ == KindOneofCase.BoolValue) {

output.WriteRawTag(112);

output.WriteBool(BoolValue);

}

if (kindCase_ == KindOneofCase.TensorShapeValue) {

output.WriteRawTag(250, 1);

output.WriteMessage(TensorShapeValue);

}

if (kindCase_ == KindOneofCase.TensorDtypeValue) {

output.WriteRawTag(128, 2);

output.WriteEnum((int) TensorDtypeValue);

}

if (kindCase_ == KindOneofCase.TensorSpecValue) {

output.WriteRawTag(138, 2);

output.WriteMessage(TensorSpecValue);

}

if (kindCase_ == KindOneofCase.TypeSpecValue) {

output.WriteRawTag(146, 2);

output.WriteMessage(TypeSpecValue);

}

if (kindCase_ == KindOneofCase.BoundedTensorSpecValue) {

output.WriteRawTag(154, 2);

output.WriteMessage(BoundedTensorSpecValue);

}

if (kindCase_ == KindOneofCase.ListValue) {

output.WriteRawTag(154, 3);

output.WriteMessage(ListValue);

}

if (kindCase_ == KindOneofCase.TupleValue) {

output.WriteRawTag(162, 3);

output.WriteMessage(TupleValue);

}

if (kindCase_ == KindOneofCase.DictValue) {

output.WriteRawTag(170, 3);

output.WriteMessage(DictValue);

}

if (kindCase_ == KindOneofCase.NamedTupleValue) {

output.WriteRawTag(178, 3);

output.WriteMessage(NamedTupleValue);

}

if (_unknownFields != null) {

_unknownFields.WriteTo(output);

}

#endif

}

#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

if (kindCase_ == KindOneofCase.NoneValue) {

output.WriteRawTag(10);

output.WriteMessage(NoneValue);

}

if (kindCase_ == KindOneofCase.Float64Value) {

output.WriteRawTag(89);

output.WriteDouble(Float64Value);

}

if (kindCase_ == KindOneofCase.Int64Value) {

output.WriteRawTag(96);

output.WriteSInt64(Int64Value);

}

if (kindCase_ == KindOneofCase.StringValue) {

output.WriteRawTag(106);

output.WriteString(StringValue);

}

if (kindCase_ == KindOneofCase.BoolValue) {

output.WriteRawTag(112);

output.WriteBool(BoolValue);

}

if (kindCase_ == KindOneofCase.TensorShapeValue) {

output.WriteRawTag(250, 1);

output.WriteMessage(TensorShapeValue);

}

if (kindCase_ == KindOneofCase.TensorDtypeValue) {

output.WriteRawTag(128, 2);

output.WriteEnum((int) TensorDtypeValue);

}

if (kindCase_ == KindOneofCase.TensorSpecValue) {

output.WriteRawTag(138, 2);

output.WriteMessage(TensorSpecValue);

}

if (kindCase_ == KindOneofCase.TypeSpecValue) {

output.WriteRawTag(146, 2);

output.WriteMessage(TypeSpecValue);

}

if (kindCase_ == KindOneofCase.BoundedTensorSpecValue) {

output.WriteRawTag(154, 2);

output.WriteMessage(BoundedTensorSpecValue);

}

if (kindCase_ == KindOneofCase.ListValue) {

output.WriteRawTag(154, 3);

output.WriteMessage(ListValue);

}

if (kindCase_ == KindOneofCase.TupleValue) {

output.WriteRawTag(162, 3);

output.WriteMessage(TupleValue);

}

if (kindCase_ == KindOneofCase.DictValue) {

output.WriteRawTag(170, 3);

output.WriteMessage(DictValue);

}

if (kindCase_ == KindOneofCase.NamedTupleValue) {

output.WriteRawTag(178, 3);

output.WriteMessage(NamedTupleValue);

}

if (_unknownFields != null) {

_unknownFields.WriteTo(ref output);

}

}

#endif

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public int CalculateSize() {

int size = 0;

if (kindCase_ == KindOneofCase.NoneValue) {

size += 1 + pb::CodedOutputStream.ComputeMessageSize(NoneValue);

}

if (kindCase_ == KindOneofCase.Float64Value) {

size += 1 + 8;

}

if (kindCase_ == KindOneofCase.Int64Value) {

size += 1 + pb::CodedOutputStream.ComputeSInt64Size(Int64Value);

}

if (kindCase_ == KindOneofCase.StringValue) {

size += 1 + pb::CodedOutputStream.ComputeStringSize(StringValue);

}

if (kindCase_ == KindOneofCase.BoolValue) {

size += 1 + 1;

}

if (kindCase_ == KindOneofCase.TensorShapeValue) {

size += 2 + pb::CodedOutputStream.ComputeMessageSize(TensorShapeValue);

}

if (kindCase_ == KindOneofCase.TensorDtypeValue) {

size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) TensorDtypeValue);

}

if (kindCase_ == KindOneofCase.TensorSpecValue) {

size += 2 + pb::CodedOutputStream.ComputeMessageSize(TensorSpecValue);

}

if (kindCase_ == KindOneofCase.TypeSpecValue) {

size += 2 + pb::CodedOutputStream.ComputeMessageSize(TypeSpecValue);

}

if (kindCase_ == KindOneofCase.BoundedTensorSpecValue) {

size += 2 + pb::CodedOutputStream.ComputeMessageSize(BoundedTensorSpecValue);

}

if (kindCase_ == KindOneofCase.ListValue) {

size += 2 + pb::CodedOutputStream.ComputeMessageSize(ListValue);

}

if (kindCase_ == KindOneofCase.TupleValue) {

size += 2 + pb::CodedOutputStream.ComputeMessageSize(TupleValue);

}

if (kindCase_ == KindOneofCase.DictValue) {

size += 2 + pb::CodedOutputStream.ComputeMessageSize(DictValue);

}

if (kindCase_ == KindOneofCase.NamedTupleValue) {

size += 2 + pb::CodedOutputStream.ComputeMessageSize(NamedTupleValue);

}

if (_unknownFields != null) {

size += _unknownFields.CalculateSize();

}

return size;

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public void MergeFrom(StructuredValue other) {

if (other == null) {