vendor/google.golang.org/genproto/googleapis/datastore/v1beta3/entity.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/datastore/v1beta3/entity.proto
   3
   4 package datastore
   5
   6 import proto "github.com/golang/protobuf/proto"
   7 import fmt "fmt"
   8 import math "math"
   9 import _ "google.golang.org/genproto/googleapis/api/annotations"
  10 import google_protobuf1 "github.com/golang/protobuf/ptypes/struct"
  11 import google_protobuf2 "github.com/golang/protobuf/ptypes/timestamp"
  12 import google_type "google.golang.org/genproto/googleapis/type/latlng"
  13
  14 // Reference imports to suppress errors if they are not otherwise used.
  15 var _ = proto.Marshal
  16 var _ = fmt.Errorf
  17 var _ = math.Inf
  18
  19 // A partition ID identifies a grouping of entities. The grouping is always
  20 // by project and namespace, however the namespace ID may be empty.
  21 //
  22 // A partition ID contains several dimensions:
  23 // project ID and namespace ID.
  24 //
  25 // Partition dimensions:
  26 //
  27 // - May be `""`.
  28 // - Must be valid UTF-8 bytes.
  29 // - Must have values that match regex `[A-Za-z\d\.\-_]{1,100}`
  30 // If the value of any dimension matches regex `__.*__`, the partition is
  31 // reserved/read-only.
  32 // A reserved/read-only partition ID is forbidden in certain documented
  33 // contexts.
  34 //
  35 // Foreign partition IDs (in which the project ID does
  36 // not match the context project ID ) are discouraged.
  37 // Reads and writes of foreign partition IDs may fail if the project is not in an active state.
  38 type PartitionId struct {
  39         // The ID of the project to which the entities belong.
  40         ProjectId string `protobuf:"bytes,2,opt,name=project_id,json=projectId" json:"project_id,omitempty"`
  41         // If not empty, the ID of the namespace to which the entities belong.
  42         NamespaceId string `protobuf:"bytes,4,opt,name=namespace_id,json=namespaceId" json:"namespace_id,omitempty"`
  43 }
  44
  45 func (m *PartitionId) Reset()                    { *m = PartitionId{} }
  46 func (m *PartitionId) String() string            { return proto.CompactTextString(m) }
  47 func (*PartitionId) ProtoMessage()               {}
  48 func (*PartitionId) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
  49
  50 func (m *PartitionId) GetProjectId() string {
  51         if m != nil {
  52                 return m.ProjectId
  53         }
  54         return ""
  55 }
  56
  57 func (m *PartitionId) GetNamespaceId() string {
  58         if m != nil {
  59                 return m.NamespaceId
  60         }
  61         return ""
  62 }
  63
  64 // A unique identifier for an entity.
  65 // If a key's partition ID or any of its path kinds or names are
  66 // reserved/read-only, the key is reserved/read-only.
  67 // A reserved/read-only key is forbidden in certain documented contexts.
  68 type Key struct {
  69         // Entities are partitioned into subsets, currently identified by a project
  70         // ID and namespace ID.
  71         // Queries are scoped to a single partition.
  72         PartitionId *PartitionId `protobuf:"bytes,1,opt,name=partition_id,json=partitionId" json:"partition_id,omitempty"`
  73         // The entity path.
  74         // An entity path consists of one or more elements composed of a kind and a
  75         // string or numerical identifier, which identify entities. The first
  76         // element identifies a _root entity_, the second element identifies
  77         // a _child_ of the root entity, the third element identifies a child of the
  78         // second entity, and so forth. The entities identified by all prefixes of
  79         // the path are called the element's _ancestors_.
  80         //
  81         // An entity path is always fully complete: *all* of the entity's ancestors
  82         // are required to be in the path along with the entity identifier itself.
  83         // The only exception is that in some documented cases, the identifier in the
  84         // last path element (for the entity) itself may be omitted. For example,
  85         // the last path element of the key of `Mutation.insert` may have no
  86         // identifier.
  87         //
  88         // A path can never be empty, and a path can have at most 100 elements.
  89         Path []*Key_PathElement `protobuf:"bytes,2,rep,name=path" json:"path,omitempty"`
  90 }
  91
  92 func (m *Key) Reset()                    { *m = Key{} }
  93 func (m *Key) String() string            { return proto.CompactTextString(m) }
  94 func (*Key) ProtoMessage()               {}
  95 func (*Key) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
  96
  97 func (m *Key) GetPartitionId() *PartitionId {
  98         if m != nil {
  99                 return m.PartitionId
 100         }
 101         return nil
 102 }
 103
 104 func (m *Key) GetPath() []*Key_PathElement {
 105         if m != nil {
 106                 return m.Path
 107         }
 108         return nil
 109 }
 110
 111 // A (kind, ID/name) pair used to construct a key path.
 112 //
 113 // If either name or ID is set, the element is complete.
 114 // If neither is set, the element is incomplete.
 115 type Key_PathElement struct {
 116         // The kind of the entity.
 117         // A kind matching regex `__.*__` is reserved/read-only.
 118         // A kind must not contain more than 1500 bytes when UTF-8 encoded.
 119         // Cannot be `""`.
 120         Kind string `protobuf:"bytes,1,opt,name=kind" json:"kind,omitempty"`
 121         // The type of ID.
 122         //
 123         // Types that are valid to be assigned to IdType:
 124         //      *Key_PathElement_Id
 125         //      *Key_PathElement_Name
 126         IdType isKey_PathElement_IdType `protobuf_oneof:"id_type"`
 127 }
 128
 129 func (m *Key_PathElement) Reset()                    { *m = Key_PathElement{} }
 130 func (m *Key_PathElement) String() string            { return proto.CompactTextString(m) }
 131 func (*Key_PathElement) ProtoMessage()               {}
 132 func (*Key_PathElement) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1, 0} }
 133
 134 type isKey_PathElement_IdType interface {
 135         isKey_PathElement_IdType()
 136 }
 137
 138 type Key_PathElement_Id struct {
 139         Id int64 `protobuf:"varint,2,opt,name=id,oneof"`
 140 }
 141 type Key_PathElement_Name struct {
 142         Name string `protobuf:"bytes,3,opt,name=name,oneof"`
 143 }
 144
 145 func (*Key_PathElement_Id) isKey_PathElement_IdType()   {}
 146 func (*Key_PathElement_Name) isKey_PathElement_IdType() {}
 147
 148 func (m *Key_PathElement) GetIdType() isKey_PathElement_IdType {
 149         if m != nil {
 150                 return m.IdType
 151         }
 152         return nil
 153 }
 154
 155 func (m *Key_PathElement) GetKind() string {
 156         if m != nil {
 157                 return m.Kind
 158         }
 159         return ""
 160 }
 161
 162 func (m *Key_PathElement) GetId() int64 {
 163         if x, ok := m.GetIdType().(*Key_PathElement_Id); ok {
 164                 return x.Id
 165         }
 166         return 0
 167 }
 168
 169 func (m *Key_PathElement) GetName() string {
 170         if x, ok := m.GetIdType().(*Key_PathElement_Name); ok {
 171                 return x.Name
 172         }
 173         return ""
 174 }
 175
 176 // XXX_OneofFuncs is for the internal use of the proto package.
 177 func (*Key_PathElement) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 178         return _Key_PathElement_OneofMarshaler, _Key_PathElement_OneofUnmarshaler, _Key_PathElement_OneofSizer, []interface{}{
 179                 (*Key_PathElement_Id)(nil),
 180                 (*Key_PathElement_Name)(nil),
 181         }
 182 }
 183
 184 func _Key_PathElement_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 185         m := msg.(*Key_PathElement)
 186         // id_type
 187         switch x := m.IdType.(type) {
 188         case *Key_PathElement_Id:
 189                 b.EncodeVarint(2<<3 | proto.WireVarint)
 190                 b.EncodeVarint(uint64(x.Id))
 191         case *Key_PathElement_Name:
 192                 b.EncodeVarint(3<<3 | proto.WireBytes)
 193                 b.EncodeStringBytes(x.Name)
 194         case nil:
 195         default:
 196                 return fmt.Errorf("Key_PathElement.IdType has unexpected type %T", x)
 197         }
 198         return nil
 199 }
 200
 201 func _Key_PathElement_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 202         m := msg.(*Key_PathElement)
 203         switch tag {
 204         case 2: // id_type.id
 205                 if wire != proto.WireVarint {
 206                         return true, proto.ErrInternalBadWireType
 207                 }
 208                 x, err := b.DecodeVarint()
 209                 m.IdType = &Key_PathElement_Id{int64(x)}
 210                 return true, err
 211         case 3: // id_type.name
 212                 if wire != proto.WireBytes {
 213                         return true, proto.ErrInternalBadWireType
 214                 }
 215                 x, err := b.DecodeStringBytes()
 216                 m.IdType = &Key_PathElement_Name{x}
 217                 return true, err
 218         default:
 219                 return false, nil
 220         }
 221 }
 222
 223 func _Key_PathElement_OneofSizer(msg proto.Message) (n int) {
 224         m := msg.(*Key_PathElement)
 225         // id_type
 226         switch x := m.IdType.(type) {
 227         case *Key_PathElement_Id:
 228                 n += proto.SizeVarint(2<<3 | proto.WireVarint)
 229                 n += proto.SizeVarint(uint64(x.Id))
 230         case *Key_PathElement_Name:
 231                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 232                 n += proto.SizeVarint(uint64(len(x.Name)))
 233                 n += len(x.Name)
 234         case nil:
 235         default:
 236                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 237         }
 238         return n
 239 }
 240
 241 // An array value.
 242 type ArrayValue struct {
 243         // Values in the array.
 244         // The order of this array may not be preserved if it contains a mix of
 245         // indexed and unindexed values.
 246         Values []*Value `protobuf:"bytes,1,rep,name=values" json:"values,omitempty"`
 247 }
 248
 249 func (m *ArrayValue) Reset()                    { *m = ArrayValue{} }
 250 func (m *ArrayValue) String() string            { return proto.CompactTextString(m) }
 251 func (*ArrayValue) ProtoMessage()               {}
 252 func (*ArrayValue) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} }
 253
 254 func (m *ArrayValue) GetValues() []*Value {
 255         if m != nil {
 256                 return m.Values
 257         }
 258         return nil
 259 }
 260
 261 // A message that can hold any of the supported value types and associated
 262 // metadata.
 263 type Value struct {
 264         // Must have a value set.
 265         //
 266         // Types that are valid to be assigned to ValueType:
 267         //      *Value_NullValue
 268         //      *Value_BooleanValue
 269         //      *Value_IntegerValue
 270         //      *Value_DoubleValue
 271         //      *Value_TimestampValue
 272         //      *Value_KeyValue
 273         //      *Value_StringValue
 274         //      *Value_BlobValue
 275         //      *Value_GeoPointValue
 276         //      *Value_EntityValue
 277         //      *Value_ArrayValue
 278         ValueType isValue_ValueType `protobuf_oneof:"value_type"`
 279         // The `meaning` field should only be populated for backwards compatibility.
 280         Meaning int32 `protobuf:"varint,14,opt,name=meaning" json:"meaning,omitempty"`
 281         // If the value should be excluded from all indexes including those defined
 282         // explicitly.
 283         ExcludeFromIndexes bool `protobuf:"varint,19,opt,name=exclude_from_indexes,json=excludeFromIndexes" json:"exclude_from_indexes,omitempty"`
 284 }
 285
 286 func (m *Value) Reset()                    { *m = Value{} }
 287 func (m *Value) String() string            { return proto.CompactTextString(m) }
 288 func (*Value) ProtoMessage()               {}
 289 func (*Value) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} }
 290
 291 type isValue_ValueType interface {
 292         isValue_ValueType()
 293 }
 294
 295 type Value_NullValue struct {
 296         NullValue google_protobuf1.NullValue `protobuf:"varint,11,opt,name=null_value,json=nullValue,enum=google.protobuf.NullValue,oneof"`
 297 }
 298 type Value_BooleanValue struct {
 299         BooleanValue bool `protobuf:"varint,1,opt,name=boolean_value,json=booleanValue,oneof"`
 300 }
 301 type Value_IntegerValue struct {
 302         IntegerValue int64 `protobuf:"varint,2,opt,name=integer_value,json=integerValue,oneof"`
 303 }
 304 type Value_DoubleValue struct {
 305         DoubleValue float64 `protobuf:"fixed64,3,opt,name=double_value,json=doubleValue,oneof"`
 306 }
 307 type Value_TimestampValue struct {
 308         TimestampValue *google_protobuf2.Timestamp `protobuf:"bytes,10,opt,name=timestamp_value,json=timestampValue,oneof"`
 309 }
 310 type Value_KeyValue struct {
 311         KeyValue *Key `protobuf:"bytes,5,opt,name=key_value,json=keyValue,oneof"`
 312 }
 313 type Value_StringValue struct {
 314         StringValue string `protobuf:"bytes,17,opt,name=string_value,json=stringValue,oneof"`
 315 }
 316 type Value_BlobValue struct {
 317         BlobValue []byte `protobuf:"bytes,18,opt,name=blob_value,json=blobValue,proto3,oneof"`
 318 }
 319 type Value_GeoPointValue struct {
 320         GeoPointValue *google_type.LatLng `protobuf:"bytes,8,opt,name=geo_point_value,json=geoPointValue,oneof"`
 321 }
 322 type Value_EntityValue struct {
 323         EntityValue *Entity `protobuf:"bytes,6,opt,name=entity_value,json=entityValue,oneof"`
 324 }
 325 type Value_ArrayValue struct {
 326         ArrayValue *ArrayValue `protobuf:"bytes,9,opt,name=array_value,json=arrayValue,oneof"`
 327 }
 328
 329 func (*Value_NullValue) isValue_ValueType()      {}
 330 func (*Value_BooleanValue) isValue_ValueType()   {}
 331 func (*Value_IntegerValue) isValue_ValueType()   {}
 332 func (*Value_DoubleValue) isValue_ValueType()    {}
 333 func (*Value_TimestampValue) isValue_ValueType() {}
 334 func (*Value_KeyValue) isValue_ValueType()       {}
 335 func (*Value_StringValue) isValue_ValueType()    {}
 336 func (*Value_BlobValue) isValue_ValueType()      {}
 337 func (*Value_GeoPointValue) isValue_ValueType()  {}
 338 func (*Value_EntityValue) isValue_ValueType()    {}
 339 func (*Value_ArrayValue) isValue_ValueType()     {}
 340
 341 func (m *Value) GetValueType() isValue_ValueType {
 342         if m != nil {
 343                 return m.ValueType
 344         }
 345         return nil
 346 }
 347
 348 func (m *Value) GetNullValue() google_protobuf1.NullValue {
 349         if x, ok := m.GetValueType().(*Value_NullValue); ok {
 350                 return x.NullValue
 351         }
 352         return google_protobuf1.NullValue_NULL_VALUE
 353 }
 354
 355 func (m *Value) GetBooleanValue() bool {
 356         if x, ok := m.GetValueType().(*Value_BooleanValue); ok {
 357                 return x.BooleanValue
 358         }
 359         return false
 360 }
 361
 362 func (m *Value) GetIntegerValue() int64 {
 363         if x, ok := m.GetValueType().(*Value_IntegerValue); ok {
 364                 return x.IntegerValue
 365         }
 366         return 0
 367 }
 368
 369 func (m *Value) GetDoubleValue() float64 {
 370         if x, ok := m.GetValueType().(*Value_DoubleValue); ok {
 371                 return x.DoubleValue
 372         }
 373         return 0
 374 }
 375
 376 func (m *Value) GetTimestampValue() *google_protobuf2.Timestamp {
 377         if x, ok := m.GetValueType().(*Value_TimestampValue); ok {
 378                 return x.TimestampValue
 379         }
 380         return nil
 381 }
 382
 383 func (m *Value) GetKeyValue() *Key {
 384         if x, ok := m.GetValueType().(*Value_KeyValue); ok {
 385                 return x.KeyValue
 386         }
 387         return nil
 388 }
 389
 390 func (m *Value) GetStringValue() string {
 391         if x, ok := m.GetValueType().(*Value_StringValue); ok {
 392                 return x.StringValue
 393         }
 394         return ""
 395 }
 396
 397 func (m *Value) GetBlobValue() []byte {
 398         if x, ok := m.GetValueType().(*Value_BlobValue); ok {
 399                 return x.BlobValue
 400         }
 401         return nil
 402 }
 403
 404 func (m *Value) GetGeoPointValue() *google_type.LatLng {
 405         if x, ok := m.GetValueType().(*Value_GeoPointValue); ok {
 406                 return x.GeoPointValue
 407         }
 408         return nil
 409 }
 410
 411 func (m *Value) GetEntityValue() *Entity {
 412         if x, ok := m.GetValueType().(*Value_EntityValue); ok {
 413                 return x.EntityValue
 414         }
 415         return nil
 416 }
 417
 418 func (m *Value) GetArrayValue() *ArrayValue {
 419         if x, ok := m.GetValueType().(*Value_ArrayValue); ok {
 420                 return x.ArrayValue
 421         }
 422         return nil
 423 }
 424
 425 func (m *Value) GetMeaning() int32 {
 426         if m != nil {
 427                 return m.Meaning
 428         }
 429         return 0
 430 }
 431
 432 func (m *Value) GetExcludeFromIndexes() bool {
 433         if m != nil {
 434                 return m.ExcludeFromIndexes
 435         }
 436         return false
 437 }
 438
 439 // XXX_OneofFuncs is for the internal use of the proto package.
 440 func (*Value) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 441         return _Value_OneofMarshaler, _Value_OneofUnmarshaler, _Value_OneofSizer, []interface{}{
 442                 (*Value_NullValue)(nil),
 443                 (*Value_BooleanValue)(nil),
 444                 (*Value_IntegerValue)(nil),
 445                 (*Value_DoubleValue)(nil),
 446                 (*Value_TimestampValue)(nil),
 447                 (*Value_KeyValue)(nil),
 448                 (*Value_StringValue)(nil),
 449                 (*Value_BlobValue)(nil),
 450                 (*Value_GeoPointValue)(nil),
 451                 (*Value_EntityValue)(nil),
 452                 (*Value_ArrayValue)(nil),
 453         }
 454 }
 455
 456 func _Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 457         m := msg.(*Value)
 458         // value_type
 459         switch x := m.ValueType.(type) {
 460         case *Value_NullValue:
 461                 b.EncodeVarint(11<<3 | proto.WireVarint)
 462                 b.EncodeVarint(uint64(x.NullValue))
 463         case *Value_BooleanValue:
 464                 t := uint64(0)
 465                 if x.BooleanValue {
 466                         t = 1
 467                 }
 468                 b.EncodeVarint(1<<3 | proto.WireVarint)
 469                 b.EncodeVarint(t)
 470         case *Value_IntegerValue:
 471                 b.EncodeVarint(2<<3 | proto.WireVarint)
 472                 b.EncodeVarint(uint64(x.IntegerValue))
 473         case *Value_DoubleValue:
 474                 b.EncodeVarint(3<<3 | proto.WireFixed64)
 475                 b.EncodeFixed64(math.Float64bits(x.DoubleValue))
 476         case *Value_TimestampValue:
 477                 b.EncodeVarint(10<<3 | proto.WireBytes)
 478                 if err := b.EncodeMessage(x.TimestampValue); err != nil {
 479                         return err
 480                 }
 481         case *Value_KeyValue:
 482                 b.EncodeVarint(5<<3 | proto.WireBytes)
 483                 if err := b.EncodeMessage(x.KeyValue); err != nil {
 484                         return err
 485                 }
 486         case *Value_StringValue:
 487                 b.EncodeVarint(17<<3 | proto.WireBytes)
 488                 b.EncodeStringBytes(x.StringValue)
 489         case *Value_BlobValue:
 490                 b.EncodeVarint(18<<3 | proto.WireBytes)
 491                 b.EncodeRawBytes(x.BlobValue)
 492         case *Value_GeoPointValue:
 493                 b.EncodeVarint(8<<3 | proto.WireBytes)
 494                 if err := b.EncodeMessage(x.GeoPointValue); err != nil {
 495                         return err
 496                 }
 497         case *Value_EntityValue:
 498                 b.EncodeVarint(6<<3 | proto.WireBytes)
 499                 if err := b.EncodeMessage(x.EntityValue); err != nil {
 500                         return err
 501                 }
 502         case *Value_ArrayValue:
 503                 b.EncodeVarint(9<<3 | proto.WireBytes)
 504                 if err := b.EncodeMessage(x.ArrayValue); err != nil {
 505                         return err
 506                 }
 507         case nil:
 508         default:
 509                 return fmt.Errorf("Value.ValueType has unexpected type %T", x)
 510         }
 511         return nil
 512 }
 513
 514 func _Value_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 515         m := msg.(*Value)
 516         switch tag {
 517         case 11: // value_type.null_value
 518                 if wire != proto.WireVarint {
 519                         return true, proto.ErrInternalBadWireType
 520                 }
 521                 x, err := b.DecodeVarint()
 522                 m.ValueType = &Value_NullValue{google_protobuf1.NullValue(x)}
 523                 return true, err
 524         case 1: // value_type.boolean_value
 525                 if wire != proto.WireVarint {
 526                         return true, proto.ErrInternalBadWireType
 527                 }
 528                 x, err := b.DecodeVarint()
 529                 m.ValueType = &Value_BooleanValue{x != 0}
 530                 return true, err
 531         case 2: // value_type.integer_value
 532                 if wire != proto.WireVarint {
 533                         return true, proto.ErrInternalBadWireType
 534                 }
 535                 x, err := b.DecodeVarint()
 536                 m.ValueType = &Value_IntegerValue{int64(x)}
 537                 return true, err
 538         case 3: // value_type.double_value
 539                 if wire != proto.WireFixed64 {
 540                         return true, proto.ErrInternalBadWireType
 541                 }
 542                 x, err := b.DecodeFixed64()
 543                 m.ValueType = &Value_DoubleValue{math.Float64frombits(x)}
 544                 return true, err
 545         case 10: // value_type.timestamp_value
 546                 if wire != proto.WireBytes {
 547                         return true, proto.ErrInternalBadWireType
 548                 }
 549                 msg := new(google_protobuf2.Timestamp)
 550                 err := b.DecodeMessage(msg)
 551                 m.ValueType = &Value_TimestampValue{msg}
 552                 return true, err
 553         case 5: // value_type.key_value
 554                 if wire != proto.WireBytes {
 555                         return true, proto.ErrInternalBadWireType
 556                 }
 557                 msg := new(Key)
 558                 err := b.DecodeMessage(msg)
 559                 m.ValueType = &Value_KeyValue{msg}
 560                 return true, err
 561         case 17: // value_type.string_value
 562                 if wire != proto.WireBytes {
 563                         return true, proto.ErrInternalBadWireType
 564                 }
 565                 x, err := b.DecodeStringBytes()
 566                 m.ValueType = &Value_StringValue{x}
 567                 return true, err
 568         case 18: // value_type.blob_value
 569                 if wire != proto.WireBytes {
 570                         return true, proto.ErrInternalBadWireType
 571                 }
 572                 x, err := b.DecodeRawBytes(true)
 573                 m.ValueType = &Value_BlobValue{x}
 574                 return true, err
 575         case 8: // value_type.geo_point_value
 576                 if wire != proto.WireBytes {
 577                         return true, proto.ErrInternalBadWireType
 578                 }
 579                 msg := new(google_type.LatLng)
 580                 err := b.DecodeMessage(msg)
 581                 m.ValueType = &Value_GeoPointValue{msg}
 582                 return true, err
 583         case 6: // value_type.entity_value
 584                 if wire != proto.WireBytes {
 585                         return true, proto.ErrInternalBadWireType
 586                 }
 587                 msg := new(Entity)
 588                 err := b.DecodeMessage(msg)
 589                 m.ValueType = &Value_EntityValue{msg}
 590                 return true, err
 591         case 9: // value_type.array_value
 592                 if wire != proto.WireBytes {
 593                         return true, proto.ErrInternalBadWireType
 594                 }
 595                 msg := new(ArrayValue)
 596                 err := b.DecodeMessage(msg)
 597                 m.ValueType = &Value_ArrayValue{msg}
 598                 return true, err
 599         default:
 600                 return false, nil
 601         }
 602 }
 603
 604 func _Value_OneofSizer(msg proto.Message) (n int) {
 605         m := msg.(*Value)
 606         // value_type
 607         switch x := m.ValueType.(type) {
 608         case *Value_NullValue:
 609                 n += proto.SizeVarint(11<<3 | proto.WireVarint)
 610                 n += proto.SizeVarint(uint64(x.NullValue))
 611         case *Value_BooleanValue:
 612                 n += proto.SizeVarint(1<<3 | proto.WireVarint)
 613                 n += 1
 614         case *Value_IntegerValue:
 615                 n += proto.SizeVarint(2<<3 | proto.WireVarint)
 616                 n += proto.SizeVarint(uint64(x.IntegerValue))
 617         case *Value_DoubleValue:
 618                 n += proto.SizeVarint(3<<3 | proto.WireFixed64)
 619                 n += 8
 620         case *Value_TimestampValue:
 621                 s := proto.Size(x.TimestampValue)
 622                 n += proto.SizeVarint(10<<3 | proto.WireBytes)
 623                 n += proto.SizeVarint(uint64(s))
 624                 n += s
 625         case *Value_KeyValue:
 626                 s := proto.Size(x.KeyValue)
 627                 n += proto.SizeVarint(5<<3 | proto.WireBytes)
 628                 n += proto.SizeVarint(uint64(s))
 629                 n += s
 630         case *Value_StringValue:
 631                 n += proto.SizeVarint(17<<3 | proto.WireBytes)
 632                 n += proto.SizeVarint(uint64(len(x.StringValue)))
 633                 n += len(x.StringValue)
 634         case *Value_BlobValue:
 635                 n += proto.SizeVarint(18<<3 | proto.WireBytes)
 636                 n += proto.SizeVarint(uint64(len(x.BlobValue)))
 637                 n += len(x.BlobValue)
 638         case *Value_GeoPointValue:
 639                 s := proto.Size(x.GeoPointValue)
 640                 n += proto.SizeVarint(8<<3 | proto.WireBytes)
 641                 n += proto.SizeVarint(uint64(s))
 642                 n += s
 643         case *Value_EntityValue:
 644                 s := proto.Size(x.EntityValue)
 645                 n += proto.SizeVarint(6<<3 | proto.WireBytes)
 646                 n += proto.SizeVarint(uint64(s))
 647                 n += s
 648         case *Value_ArrayValue:
 649                 s := proto.Size(x.ArrayValue)
 650                 n += proto.SizeVarint(9<<3 | proto.WireBytes)
 651                 n += proto.SizeVarint(uint64(s))
 652                 n += s
 653         case nil:
 654         default:
 655                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 656         }
 657         return n
 658 }
 659
 660 // A Datastore data object.
 661 //
 662 // An entity is limited to 1 megabyte when stored. That _roughly_
 663 // corresponds to a limit of 1 megabyte for the serialized form of this
 664 // message.
 665 type Entity struct {
 666         // The entity's key.
 667         //
 668         // An entity must have a key, unless otherwise documented (for example,
 669         // an entity in `Value.entity_value` may have no key).
 670         // An entity's kind is its key path's last element's kind,
 671         // or null if it has no key.
 672         Key *Key `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
 673         // The entity's properties.
 674         // The map's keys are property names.
 675         // A property name matching regex `__.*__` is reserved.
 676         // A reserved property name is forbidden in certain documented contexts.
 677         // The name must not contain more than 500 characters.
 678         // The name cannot be `""`.
 679         Properties map[string]*Value `protobuf:"bytes,3,rep,name=properties" json:"properties,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
 680 }
 681
 682 func (m *Entity) Reset()                    { *m = Entity{} }
 683 func (m *Entity) String() string            { return proto.CompactTextString(m) }
 684 func (*Entity) ProtoMessage()               {}
 685 func (*Entity) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} }
 686
 687 func (m *Entity) GetKey() *Key {
 688         if m != nil {
 689                 return m.Key
 690         }
 691         return nil
 692 }
 693
 694 func (m *Entity) GetProperties() map[string]*Value {
 695         if m != nil {
 696                 return m.Properties
 697         }
 698         return nil
 699 }
 700
 701 func init() {
 702         proto.RegisterType((*PartitionId)(nil), "google.datastore.v1beta3.PartitionId")
 703         proto.RegisterType((*Key)(nil), "google.datastore.v1beta3.Key")
 704         proto.RegisterType((*Key_PathElement)(nil), "google.datastore.v1beta3.Key.PathElement")
 705         proto.RegisterType((*ArrayValue)(nil), "google.datastore.v1beta3.ArrayValue")
 706         proto.RegisterType((*Value)(nil), "google.datastore.v1beta3.Value")
 707         proto.RegisterType((*Entity)(nil), "google.datastore.v1beta3.Entity")
 708 }
 709
 710 func init() { proto.RegisterFile("google/datastore/v1beta3/entity.proto", fileDescriptor1) }
 711
 712 var fileDescriptor1 = []byte{
 713         // 776 bytes of a gzipped FileDescriptorProto
 714         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x95, 0xcf, 0x8e, 0xdb, 0x36,
 715         0x10, 0xc6, 0x25, 0x7b, 0xed, 0xac, 0x46, 0xca, 0x6e, 0xca, 0xe4, 0x20, 0x18, 0x49, 0xd7, 0x75,
 716         0xbb, 0x80, 0x7b, 0x91, 0x92, 0x0d, 0x8a, 0x16, 0x4d, 0x73, 0x88, 0x5b, 0x37, 0x32, 0x12, 0xb4,
 717         0x06, 0x11, 0xe4, 0xd0, 0x43, 0x0d, 0xda, 0x62, 0x14, 0xd6, 0x12, 0x29, 0x48, 0x54, 0x10, 0x3d,
 718         0x46, 0x5f, 0xa3, 0x7d, 0xad, 0xde, 0xfa, 0x12, 0x05, 0xff, 0x48, 0x5e, 0x24, 0xf0, 0x36, 0x37,
 719         0x71, 0xe6, 0x37, 0x1f, 0x3f, 0x72, 0x86, 0x36, 0x5c, 0x66, 0x42, 0x64, 0x39, 0x8d, 0x53, 0x22,
 720         0x49, 0x2d, 0x45, 0x45, 0xe3, 0x77, 0x8f, 0xb6, 0x54, 0x92, 0xc7, 0x31, 0xe5, 0x92, 0xc9, 0x36,
 721         0x2a, 0x2b, 0x21, 0x05, 0x0a, 0x0d, 0x16, 0xf5, 0x58, 0x64, 0xb1, 0xc9, 0x7d, 0x2b, 0x40, 0x4a,
 722         0x16, 0x13, 0xce, 0x85, 0x24, 0x92, 0x09, 0x5e, 0x9b, 0xba, 0x3e, 0xab, 0x57, 0xdb, 0xe6, 0x4d,
 723         0x5c, 0xcb, 0xaa, 0xd9, 0x49, 0x9b, 0xbd, 0xf8, 0x30, 0x2b, 0x59, 0x41, 0x6b, 0x49, 0x8a, 0xd2,
 724         0x02, 0x76, 0xdb, 0x58, 0xb6, 0x25, 0x8d, 0x73, 0x22, 0x73, 0x9e, 0x99, 0xcc, 0xec, 0x57, 0xf0,
 725         0xd7, 0xa4, 0x92, 0x4c, 0x6d, 0xb6, 0x4a, 0xd1, 0x03, 0x80, 0xb2, 0x12, 0x7f, 0xd0, 0x9d, 0xdc,
 726         0xb0, 0x34, 0x1c, 0x4c, 0xdd, 0xb9, 0x87, 0x3d, 0x1b, 0x59, 0xa5, 0xe8, 0x0b, 0x08, 0x38, 0x29,
 727         0x68, 0x5d, 0x92, 0x1d, 0x55, 0xc0, 0x89, 0x06, 0xfc, 0x3e, 0xb6, 0x4a, 0x67, 0xff, 0xb8, 0x30,
 728         0x7c, 0x41, 0x5b, 0x94, 0x40, 0x50, 0x76, 0xc2, 0x0a, 0x75, 0xa7, 0xee, 0xdc, 0xbf, 0xba, 0x8c,
 729         0x8e, 0x5d, 0x40, 0x74, 0xcd, 0x06, 0xf6, 0xcb, 0x6b, 0x9e, 0x9e, 0xc2, 0x49, 0x49, 0xe4, 0xdb,
 730         0x70, 0x30, 0x1d, 0xce, 0xfd, 0xab, 0xaf, 0x8f, 0x2b, 0xbc, 0xa0, 0x6d, 0xb4, 0x26, 0xf2, 0xed,
 731         0x32, 0xa7, 0x05, 0xe5, 0x12, 0xeb, 0xb2, 0xc9, 0x2b, 0x75, 0xc2, 0x3e, 0x88, 0x10, 0x9c, 0xec,
 732         0x19, 0x37, 0x7e, 0x3c, 0xac, 0xbf, 0xd1, 0x1d, 0x18, 0xd8, 0xd3, 0x0e, 0x13, 0x07, 0x0f, 0x58,
 733         0x8a, 0xee, 0xc1, 0x89, 0x3a, 0x54, 0x38, 0x54, 0x54, 0xe2, 0x60, 0xbd, 0x5a, 0x78, 0x70, 0x8b,
 734         0xa5, 0x1b, 0x75, 0x89, 0xb3, 0x25, 0xc0, 0xb3, 0xaa, 0x22, 0xed, 0x6b, 0x92, 0x37, 0x14, 0x7d,
 735         0x0b, 0xe3, 0x77, 0xea, 0xa3, 0x0e, 0x5d, 0x6d, 0xf2, 0xe2, 0xb8, 0x49, 0x5d, 0x80, 0x2d, 0x3e,
 736         0xfb, 0x7b, 0x04, 0x23, 0x23, 0xf1, 0x04, 0x80, 0x37, 0x79, 0xbe, 0xd1, 0x89, 0xd0, 0x9f, 0xba,
 737         0xf3, 0xb3, 0xab, 0x49, 0x27, 0xd3, 0x35, 0x36, 0xfa, 0xa5, 0xc9, 0x73, 0xcd, 0x27, 0x0e, 0xf6,
 738         0x78, 0xb7, 0x40, 0x97, 0x70, 0x7b, 0x2b, 0x44, 0x4e, 0x09, 0xb7, 0xf5, 0xea, 0x74, 0xa7, 0x89,
 739         0x83, 0x03, 0x1b, 0xee, 0x31, 0xc6, 0x25, 0xcd, 0x68, 0x65, 0xb1, 0xee, 0xc8, 0x81, 0x0d, 0x1b,
 740         0xec, 0x4b, 0x08, 0x52, 0xd1, 0x6c, 0x73, 0x6a, 0x29, 0x75, 0x09, 0x6e, 0xe2, 0x60, 0xdf, 0x44,
 741         0x0d, 0xb4, 0x84, 0xf3, 0x7e, 0xca, 0x2c, 0x07, 0xba, 0xc5, 0x1f, 0x9b, 0x7e, 0xd5, 0x71, 0x89,
 742         0x83, 0xcf, 0xfa, 0x22, 0x23, 0xf3, 0x03, 0x78, 0x7b, 0xda, 0x5a, 0x81, 0x91, 0x16, 0x78, 0x70,
 743         0x63, 0x87, 0x13, 0x07, 0x9f, 0xee, 0x69, 0xdb, 0x3b, 0xad, 0x65, 0xc5, 0x78, 0x66, 0x05, 0x3e,
 744         0xb3, 0xed, 0xf2, 0x4d, 0xd4, 0x40, 0x17, 0x00, 0xdb, 0x5c, 0x6c, 0x2d, 0x82, 0xa6, 0xee, 0x3c,
 745         0x50, 0xb7, 0xa7, 0x62, 0x06, 0x78, 0x0a, 0xe7, 0x19, 0x15, 0x9b, 0x52, 0x30, 0x2e, 0x2d, 0x75,
 746         0xaa, 0x9d, 0xdc, 0xed, 0x9c, 0xa8, 0x96, 0x47, 0x2f, 0x89, 0x7c, 0xc9, 0xb3, 0xc4, 0xc1, 0xb7,
 747         0x33, 0x2a, 0xd6, 0x0a, 0xee, 0x6e, 0x22, 0x30, 0x6f, 0xdc, 0xd6, 0x8e, 0x75, 0xed, 0xf4, 0xf8,
 748         0x29, 0x96, 0x9a, 0x56, 0x36, 0x4d, 0x9d, 0x91, 0x79, 0x0e, 0x3e, 0x51, 0x13, 0x65, 0x55, 0x3c,
 749         0xad, 0xf2, 0xd5, 0x71, 0x95, 0xc3, 0xf8, 0x25, 0x0e, 0x06, 0x72, 0x18, 0xc6, 0x10, 0x6e, 0x15,
 750         0x94, 0x70, 0xc6, 0xb3, 0xf0, 0x6c, 0xea, 0xce, 0x47, 0xb8, 0x5b, 0xa2, 0x87, 0x70, 0x8f, 0xbe,
 751         0xdf, 0xe5, 0x4d, 0x4a, 0x37, 0x6f, 0x2a, 0x51, 0x6c, 0x18, 0x4f, 0xe9, 0x7b, 0x5a, 0x87, 0x77,
 752         0xd5, 0xb4, 0x60, 0x64, 0x73, 0x3f, 0x57, 0xa2, 0x58, 0x99, 0xcc, 0x22, 0x00, 0xd0, 0x76, 0xcc,
 753         0xd0, 0xff, 0xeb, 0xc2, 0xd8, 0x98, 0x47, 0x31, 0x0c, 0xf7, 0xb4, 0xb5, 0xaf, 0xfa, 0xe6, 0x8e,
 754         0x61, 0x45, 0xa2, 0xb5, 0xfe, 0x65, 0x29, 0x69, 0x25, 0x19, 0xad, 0xc3, 0xa1, 0x7e, 0x26, 0x0f,
 755         0xff, 0xef, 0x8e, 0xa2, 0x75, 0x5f, 0xb2, 0xe4, 0xb2, 0x6a, 0xf1, 0x35, 0x8d, 0xc9, 0xef, 0x70,
 756         0xfe, 0x41, 0x1a, 0xdd, 0x39, 0xb8, 0xf2, 0xcc, 0xb6, 0xdf, 0xc0, 0xe8, 0x30, 0xea, 0x9f, 0xf0,
 757         0x30, 0x0d, 0xfd, 0xfd, 0xe0, 0x3b, 0x77, 0xf1, 0xa7, 0x0b, 0xf7, 0x77, 0xa2, 0x38, 0x5a, 0xb1,
 758         0xf0, 0x8d, 0xc9, 0xb5, 0x9a, 0xf3, 0xb5, 0xfb, 0xdb, 0x33, 0x0b, 0x66, 0x22, 0x27, 0x3c, 0x8b,
 759         0x44, 0x95, 0xc5, 0x19, 0xe5, 0xfa, 0x15, 0xc4, 0x26, 0x45, 0x4a, 0x56, 0x7f, 0xfc, 0x0f, 0xf1,
 760         0xa4, 0x8f, 0xfc, 0x35, 0xf8, 0xfc, 0xb9, 0xd1, 0xf8, 0x31, 0x17, 0x4d, 0x1a, 0xfd, 0xd4, 0x6f,
 761         0xf9, 0xfa, 0xd1, 0x42, 0xa1, 0xdb, 0xb1, 0x96, 0x7b, 0xfc, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff,
 762         0x7e, 0x53, 0x2d, 0x57, 0x6f, 0x06, 0x00, 0x00,
 763 }