vendor/google.golang.org/genproto/googleapis/datastore/v1/datastore.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/datastore/v1/datastore.proto
   3
   4 /*
   5 Package datastore is a generated protocol buffer package.
   6
   7 It is generated from these files:
   8         google/datastore/v1/datastore.proto
   9         google/datastore/v1/entity.proto
  10         google/datastore/v1/query.proto
  11
  12 It has these top-level messages:
  13         LookupRequest
  14         LookupResponse
  15         RunQueryRequest
  16         RunQueryResponse
  17         BeginTransactionRequest
  18         BeginTransactionResponse
  19         RollbackRequest
  20         RollbackResponse
  21         CommitRequest
  22         CommitResponse
  23         AllocateIdsRequest
  24         AllocateIdsResponse
  25         Mutation
  26         MutationResult
  27         ReadOptions
  28         TransactionOptions
  29         PartitionId
  30         Key
  31         ArrayValue
  32         Value
  33         Entity
  34         EntityResult
  35         Query
  36         KindExpression
  37         PropertyReference
  38         Projection
  39         PropertyOrder
  40         Filter
  41         CompositeFilter
  42         PropertyFilter
  43         GqlQuery
  44         GqlQueryParameter
  45         QueryResultBatch
  46 */
  47 package datastore
  48
  49 import proto "github.com/golang/protobuf/proto"
  50 import fmt "fmt"
  51 import math "math"
  52 import _ "google.golang.org/genproto/googleapis/api/annotations"
  53
  54 import (
  55         context "golang.org/x/net/context"
  56         grpc "google.golang.org/grpc"
  57 )
  58
  59 // Reference imports to suppress errors if they are not otherwise used.
  60 var _ = proto.Marshal
  61 var _ = fmt.Errorf
  62 var _ = math.Inf
  63
  64 // This is a compile-time assertion to ensure that this generated file
  65 // is compatible with the proto package it is being compiled against.
  66 // A compilation error at this line likely means your copy of the
  67 // proto package needs to be updated.
  68 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  69
  70 // The modes available for commits.
  71 type CommitRequest_Mode int32
  72
  73 const (
  74         // Unspecified. This value must not be used.
  75         CommitRequest_MODE_UNSPECIFIED CommitRequest_Mode = 0
  76         // Transactional: The mutations are either all applied, or none are applied.
  77         // Learn about transactions [here](https://cloud.google.com/datastore/docs/concepts/transactions).
  78         CommitRequest_TRANSACTIONAL CommitRequest_Mode = 1
  79         // Non-transactional: The mutations may not apply as all or none.
  80         CommitRequest_NON_TRANSACTIONAL CommitRequest_Mode = 2
  81 )
  82
  83 var CommitRequest_Mode_name = map[int32]string{
  84         0: "MODE_UNSPECIFIED",
  85         1: "TRANSACTIONAL",
  86         2: "NON_TRANSACTIONAL",
  87 }
  88 var CommitRequest_Mode_value = map[string]int32{
  89         "MODE_UNSPECIFIED":  0,
  90         "TRANSACTIONAL":     1,
  91         "NON_TRANSACTIONAL": 2,
  92 }
  93
  94 func (x CommitRequest_Mode) String() string {
  95         return proto.EnumName(CommitRequest_Mode_name, int32(x))
  96 }
  97 func (CommitRequest_Mode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{8, 0} }
  98
  99 // The possible values for read consistencies.
 100 type ReadOptions_ReadConsistency int32
 101
 102 const (
 103         // Unspecified. This value must not be used.
 104         ReadOptions_READ_CONSISTENCY_UNSPECIFIED ReadOptions_ReadConsistency = 0
 105         // Strong consistency.
 106         ReadOptions_STRONG ReadOptions_ReadConsistency = 1
 107         // Eventual consistency.
 108         ReadOptions_EVENTUAL ReadOptions_ReadConsistency = 2
 109 )
 110
 111 var ReadOptions_ReadConsistency_name = map[int32]string{
 112         0: "READ_CONSISTENCY_UNSPECIFIED",
 113         1: "STRONG",
 114         2: "EVENTUAL",
 115 }
 116 var ReadOptions_ReadConsistency_value = map[string]int32{
 117         "READ_CONSISTENCY_UNSPECIFIED": 0,
 118         "STRONG":                       1,
 119         "EVENTUAL":                     2,
 120 }
 121
 122 func (x ReadOptions_ReadConsistency) String() string {
 123         return proto.EnumName(ReadOptions_ReadConsistency_name, int32(x))
 124 }
 125 func (ReadOptions_ReadConsistency) EnumDescriptor() ([]byte, []int) {
 126         return fileDescriptor0, []int{14, 0}
 127 }
 128
 129 // The request for [Datastore.Lookup][google.datastore.v1.Datastore.Lookup].
 130 type LookupRequest struct {
 131         // The ID of the project against which to make the request.
 132         ProjectId string `protobuf:"bytes,8,opt,name=project_id,json=projectId" json:"project_id,omitempty"`
 133         // The options for this lookup request.
 134         ReadOptions *ReadOptions `protobuf:"bytes,1,opt,name=read_options,json=readOptions" json:"read_options,omitempty"`
 135         // Keys of entities to look up.
 136         Keys []*Key `protobuf:"bytes,3,rep,name=keys" json:"keys,omitempty"`
 137 }
 138
 139 func (m *LookupRequest) Reset()                    { *m = LookupRequest{} }
 140 func (m *LookupRequest) String() string            { return proto.CompactTextString(m) }
 141 func (*LookupRequest) ProtoMessage()               {}
 142 func (*LookupRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 143
 144 func (m *LookupRequest) GetProjectId() string {
 145         if m != nil {
 146                 return m.ProjectId
 147         }
 148         return ""
 149 }
 150
 151 func (m *LookupRequest) GetReadOptions() *ReadOptions {
 152         if m != nil {
 153                 return m.ReadOptions
 154         }
 155         return nil
 156 }
 157
 158 func (m *LookupRequest) GetKeys() []*Key {
 159         if m != nil {
 160                 return m.Keys
 161         }
 162         return nil
 163 }
 164
 165 // The response for [Datastore.Lookup][google.datastore.v1.Datastore.Lookup].
 166 type LookupResponse struct {
 167         // Entities found as `ResultType.FULL` entities. The order of results in this
 168         // field is undefined and has no relation to the order of the keys in the
 169         // input.
 170         Found []*EntityResult `protobuf:"bytes,1,rep,name=found" json:"found,omitempty"`
 171         // Entities not found as `ResultType.KEY_ONLY` entities. The order of results
 172         // in this field is undefined and has no relation to the order of the keys
 173         // in the input.
 174         Missing []*EntityResult `protobuf:"bytes,2,rep,name=missing" json:"missing,omitempty"`
 175         // A list of keys that were not looked up due to resource constraints. The
 176         // order of results in this field is undefined and has no relation to the
 177         // order of the keys in the input.
 178         Deferred []*Key `protobuf:"bytes,3,rep,name=deferred" json:"deferred,omitempty"`
 179 }
 180
 181 func (m *LookupResponse) Reset()                    { *m = LookupResponse{} }
 182 func (m *LookupResponse) String() string            { return proto.CompactTextString(m) }
 183 func (*LookupResponse) ProtoMessage()               {}
 184 func (*LookupResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 185
 186 func (m *LookupResponse) GetFound() []*EntityResult {
 187         if m != nil {
 188                 return m.Found
 189         }
 190         return nil
 191 }
 192
 193 func (m *LookupResponse) GetMissing() []*EntityResult {
 194         if m != nil {
 195                 return m.Missing
 196         }
 197         return nil
 198 }
 199
 200 func (m *LookupResponse) GetDeferred() []*Key {
 201         if m != nil {
 202                 return m.Deferred
 203         }
 204         return nil
 205 }
 206
 207 // The request for [Datastore.RunQuery][google.datastore.v1.Datastore.RunQuery].
 208 type RunQueryRequest struct {
 209         // The ID of the project against which to make the request.
 210         ProjectId string `protobuf:"bytes,8,opt,name=project_id,json=projectId" json:"project_id,omitempty"`
 211         // Entities are partitioned into subsets, identified by a partition ID.
 212         // Queries are scoped to a single partition.
 213         // This partition ID is normalized with the standard default context
 214         // partition ID.
 215         PartitionId *PartitionId `protobuf:"bytes,2,opt,name=partition_id,json=partitionId" json:"partition_id,omitempty"`
 216         // The options for this query.
 217         ReadOptions *ReadOptions `protobuf:"bytes,1,opt,name=read_options,json=readOptions" json:"read_options,omitempty"`
 218         // The type of query.
 219         //
 220         // Types that are valid to be assigned to QueryType:
 221         //      *RunQueryRequest_Query
 222         //      *RunQueryRequest_GqlQuery
 223         QueryType isRunQueryRequest_QueryType `protobuf_oneof:"query_type"`
 224 }
 225
 226 func (m *RunQueryRequest) Reset()                    { *m = RunQueryRequest{} }
 227 func (m *RunQueryRequest) String() string            { return proto.CompactTextString(m) }
 228 func (*RunQueryRequest) ProtoMessage()               {}
 229 func (*RunQueryRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 230
 231 type isRunQueryRequest_QueryType interface {
 232         isRunQueryRequest_QueryType()
 233 }
 234
 235 type RunQueryRequest_Query struct {
 236         Query *Query `protobuf:"bytes,3,opt,name=query,oneof"`
 237 }
 238 type RunQueryRequest_GqlQuery struct {
 239         GqlQuery *GqlQuery `protobuf:"bytes,7,opt,name=gql_query,json=gqlQuery,oneof"`
 240 }
 241
 242 func (*RunQueryRequest_Query) isRunQueryRequest_QueryType()    {}
 243 func (*RunQueryRequest_GqlQuery) isRunQueryRequest_QueryType() {}
 244
 245 func (m *RunQueryRequest) GetQueryType() isRunQueryRequest_QueryType {
 246         if m != nil {
 247                 return m.QueryType
 248         }
 249         return nil
 250 }
 251
 252 func (m *RunQueryRequest) GetProjectId() string {
 253         if m != nil {
 254                 return m.ProjectId
 255         }
 256         return ""
 257 }
 258
 259 func (m *RunQueryRequest) GetPartitionId() *PartitionId {
 260         if m != nil {
 261                 return m.PartitionId
 262         }
 263         return nil
 264 }
 265
 266 func (m *RunQueryRequest) GetReadOptions() *ReadOptions {
 267         if m != nil {
 268                 return m.ReadOptions
 269         }
 270         return nil
 271 }
 272
 273 func (m *RunQueryRequest) GetQuery() *Query {
 274         if x, ok := m.GetQueryType().(*RunQueryRequest_Query); ok {
 275                 return x.Query
 276         }
 277         return nil
 278 }
 279
 280 func (m *RunQueryRequest) GetGqlQuery() *GqlQuery {
 281         if x, ok := m.GetQueryType().(*RunQueryRequest_GqlQuery); ok {
 282                 return x.GqlQuery
 283         }
 284         return nil
 285 }
 286
 287 // XXX_OneofFuncs is for the internal use of the proto package.
 288 func (*RunQueryRequest) 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{}) {
 289         return _RunQueryRequest_OneofMarshaler, _RunQueryRequest_OneofUnmarshaler, _RunQueryRequest_OneofSizer, []interface{}{
 290                 (*RunQueryRequest_Query)(nil),
 291                 (*RunQueryRequest_GqlQuery)(nil),
 292         }
 293 }
 294
 295 func _RunQueryRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 296         m := msg.(*RunQueryRequest)
 297         // query_type
 298         switch x := m.QueryType.(type) {
 299         case *RunQueryRequest_Query:
 300                 b.EncodeVarint(3<<3 | proto.WireBytes)
 301                 if err := b.EncodeMessage(x.Query); err != nil {
 302                         return err
 303                 }
 304         case *RunQueryRequest_GqlQuery:
 305                 b.EncodeVarint(7<<3 | proto.WireBytes)
 306                 if err := b.EncodeMessage(x.GqlQuery); err != nil {
 307                         return err
 308                 }
 309         case nil:
 310         default:
 311                 return fmt.Errorf("RunQueryRequest.QueryType has unexpected type %T", x)
 312         }
 313         return nil
 314 }
 315
 316 func _RunQueryRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 317         m := msg.(*RunQueryRequest)
 318         switch tag {
 319         case 3: // query_type.query
 320                 if wire != proto.WireBytes {
 321                         return true, proto.ErrInternalBadWireType
 322                 }
 323                 msg := new(Query)
 324                 err := b.DecodeMessage(msg)
 325                 m.QueryType = &RunQueryRequest_Query{msg}
 326                 return true, err
 327         case 7: // query_type.gql_query
 328                 if wire != proto.WireBytes {
 329                         return true, proto.ErrInternalBadWireType
 330                 }
 331                 msg := new(GqlQuery)
 332                 err := b.DecodeMessage(msg)
 333                 m.QueryType = &RunQueryRequest_GqlQuery{msg}
 334                 return true, err
 335         default:
 336                 return false, nil
 337         }
 338 }
 339
 340 func _RunQueryRequest_OneofSizer(msg proto.Message) (n int) {
 341         m := msg.(*RunQueryRequest)
 342         // query_type
 343         switch x := m.QueryType.(type) {
 344         case *RunQueryRequest_Query:
 345                 s := proto.Size(x.Query)
 346                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 347                 n += proto.SizeVarint(uint64(s))
 348                 n += s
 349         case *RunQueryRequest_GqlQuery:
 350                 s := proto.Size(x.GqlQuery)
 351                 n += proto.SizeVarint(7<<3 | proto.WireBytes)
 352                 n += proto.SizeVarint(uint64(s))
 353                 n += s
 354         case nil:
 355         default:
 356                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 357         }
 358         return n
 359 }
 360
 361 // The response for [Datastore.RunQuery][google.datastore.v1.Datastore.RunQuery].
 362 type RunQueryResponse struct {
 363         // A batch of query results (always present).
 364         Batch *QueryResultBatch `protobuf:"bytes,1,opt,name=batch" json:"batch,omitempty"`
 365         // The parsed form of the `GqlQuery` from the request, if it was set.
 366         Query *Query `protobuf:"bytes,2,opt,name=query" json:"query,omitempty"`
 367 }
 368
 369 func (m *RunQueryResponse) Reset()                    { *m = RunQueryResponse{} }
 370 func (m *RunQueryResponse) String() string            { return proto.CompactTextString(m) }
 371 func (*RunQueryResponse) ProtoMessage()               {}
 372 func (*RunQueryResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
 373
 374 func (m *RunQueryResponse) GetBatch() *QueryResultBatch {
 375         if m != nil {
 376                 return m.Batch
 377         }
 378         return nil
 379 }
 380
 381 func (m *RunQueryResponse) GetQuery() *Query {
 382         if m != nil {
 383                 return m.Query
 384         }
 385         return nil
 386 }
 387
 388 // The request for [Datastore.BeginTransaction][google.datastore.v1.Datastore.BeginTransaction].
 389 type BeginTransactionRequest struct {
 390         // The ID of the project against which to make the request.
 391         ProjectId string `protobuf:"bytes,8,opt,name=project_id,json=projectId" json:"project_id,omitempty"`
 392         // Options for a new transaction.
 393         TransactionOptions *TransactionOptions `protobuf:"bytes,10,opt,name=transaction_options,json=transactionOptions" json:"transaction_options,omitempty"`
 394 }
 395
 396 func (m *BeginTransactionRequest) Reset()                    { *m = BeginTransactionRequest{} }
 397 func (m *BeginTransactionRequest) String() string            { return proto.CompactTextString(m) }
 398 func (*BeginTransactionRequest) ProtoMessage()               {}
 399 func (*BeginTransactionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
 400
 401 func (m *BeginTransactionRequest) GetProjectId() string {
 402         if m != nil {
 403                 return m.ProjectId
 404         }
 405         return ""
 406 }
 407
 408 func (m *BeginTransactionRequest) GetTransactionOptions() *TransactionOptions {
 409         if m != nil {
 410                 return m.TransactionOptions
 411         }
 412         return nil
 413 }
 414
 415 // The response for [Datastore.BeginTransaction][google.datastore.v1.Datastore.BeginTransaction].
 416 type BeginTransactionResponse struct {
 417         // The transaction identifier (always present).
 418         Transaction []byte `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
 419 }
 420
 421 func (m *BeginTransactionResponse) Reset()                    { *m = BeginTransactionResponse{} }
 422 func (m *BeginTransactionResponse) String() string            { return proto.CompactTextString(m) }
 423 func (*BeginTransactionResponse) ProtoMessage()               {}
 424 func (*BeginTransactionResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
 425
 426 func (m *BeginTransactionResponse) GetTransaction() []byte {
 427         if m != nil {
 428                 return m.Transaction
 429         }
 430         return nil
 431 }
 432
 433 // The request for [Datastore.Rollback][google.datastore.v1.Datastore.Rollback].
 434 type RollbackRequest struct {
 435         // The ID of the project against which to make the request.
 436         ProjectId string `protobuf:"bytes,8,opt,name=project_id,json=projectId" json:"project_id,omitempty"`
 437         // The transaction identifier, returned by a call to
 438         // [Datastore.BeginTransaction][google.datastore.v1.Datastore.BeginTransaction].
 439         Transaction []byte `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
 440 }
 441
 442 func (m *RollbackRequest) Reset()                    { *m = RollbackRequest{} }
 443 func (m *RollbackRequest) String() string            { return proto.CompactTextString(m) }
 444 func (*RollbackRequest) ProtoMessage()               {}
 445 func (*RollbackRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 446
 447 func (m *RollbackRequest) GetProjectId() string {
 448         if m != nil {
 449                 return m.ProjectId
 450         }
 451         return ""
 452 }
 453
 454 func (m *RollbackRequest) GetTransaction() []byte {
 455         if m != nil {
 456                 return m.Transaction
 457         }
 458         return nil
 459 }
 460
 461 // The response for [Datastore.Rollback][google.datastore.v1.Datastore.Rollback].
 462 // (an empty message).
 463 type RollbackResponse struct {
 464 }
 465
 466 func (m *RollbackResponse) Reset()                    { *m = RollbackResponse{} }
 467 func (m *RollbackResponse) String() string            { return proto.CompactTextString(m) }
 468 func (*RollbackResponse) ProtoMessage()               {}
 469 func (*RollbackResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 470
 471 // The request for [Datastore.Commit][google.datastore.v1.Datastore.Commit].
 472 type CommitRequest struct {
 473         // The ID of the project against which to make the request.
 474         ProjectId string `protobuf:"bytes,8,opt,name=project_id,json=projectId" json:"project_id,omitempty"`
 475         // The type of commit to perform. Defaults to `TRANSACTIONAL`.
 476         Mode CommitRequest_Mode `protobuf:"varint,5,opt,name=mode,enum=google.datastore.v1.CommitRequest_Mode" json:"mode,omitempty"`
 477         // Must be set when mode is `TRANSACTIONAL`.
 478         //
 479         // Types that are valid to be assigned to TransactionSelector:
 480         //      *CommitRequest_Transaction
 481         TransactionSelector isCommitRequest_TransactionSelector `protobuf_oneof:"transaction_selector"`
 482         // The mutations to perform.
 483         //
 484         // When mode is `TRANSACTIONAL`, mutations affecting a single entity are
 485         // applied in order. The following sequences of mutations affecting a single
 486         // entity are not permitted in a single `Commit` request:
 487         //
 488         // - `insert` followed by `insert`
 489         // - `update` followed by `insert`
 490         // - `upsert` followed by `insert`
 491         // - `delete` followed by `update`
 492         //
 493         // When mode is `NON_TRANSACTIONAL`, no two mutations may affect a single
 494         // entity.
 495         Mutations []*Mutation `protobuf:"bytes,6,rep,name=mutations" json:"mutations,omitempty"`
 496 }
 497
 498 func (m *CommitRequest) Reset()                    { *m = CommitRequest{} }
 499 func (m *CommitRequest) String() string            { return proto.CompactTextString(m) }
 500 func (*CommitRequest) ProtoMessage()               {}
 501 func (*CommitRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
 502
 503 type isCommitRequest_TransactionSelector interface {
 504         isCommitRequest_TransactionSelector()
 505 }
 506
 507 type CommitRequest_Transaction struct {
 508         Transaction []byte `protobuf:"bytes,1,opt,name=transaction,proto3,oneof"`
 509 }
 510
 511 func (*CommitRequest_Transaction) isCommitRequest_TransactionSelector() {}
 512
 513 func (m *CommitRequest) GetTransactionSelector() isCommitRequest_TransactionSelector {
 514         if m != nil {
 515                 return m.TransactionSelector
 516         }
 517         return nil
 518 }
 519
 520 func (m *CommitRequest) GetProjectId() string {
 521         if m != nil {
 522                 return m.ProjectId
 523         }
 524         return ""
 525 }
 526
 527 func (m *CommitRequest) GetMode() CommitRequest_Mode {
 528         if m != nil {
 529                 return m.Mode
 530         }
 531         return CommitRequest_MODE_UNSPECIFIED
 532 }
 533
 534 func (m *CommitRequest) GetTransaction() []byte {
 535         if x, ok := m.GetTransactionSelector().(*CommitRequest_Transaction); ok {
 536                 return x.Transaction
 537         }
 538         return nil
 539 }
 540
 541 func (m *CommitRequest) GetMutations() []*Mutation {
 542         if m != nil {
 543                 return m.Mutations
 544         }
 545         return nil
 546 }
 547
 548 // XXX_OneofFuncs is for the internal use of the proto package.
 549 func (*CommitRequest) 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{}) {
 550         return _CommitRequest_OneofMarshaler, _CommitRequest_OneofUnmarshaler, _CommitRequest_OneofSizer, []interface{}{
 551                 (*CommitRequest_Transaction)(nil),
 552         }
 553 }
 554
 555 func _CommitRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 556         m := msg.(*CommitRequest)
 557         // transaction_selector
 558         switch x := m.TransactionSelector.(type) {
 559         case *CommitRequest_Transaction:
 560                 b.EncodeVarint(1<<3 | proto.WireBytes)
 561                 b.EncodeRawBytes(x.Transaction)
 562         case nil:
 563         default:
 564                 return fmt.Errorf("CommitRequest.TransactionSelector has unexpected type %T", x)
 565         }
 566         return nil
 567 }
 568
 569 func _CommitRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 570         m := msg.(*CommitRequest)
 571         switch tag {
 572         case 1: // transaction_selector.transaction
 573                 if wire != proto.WireBytes {
 574                         return true, proto.ErrInternalBadWireType
 575                 }
 576                 x, err := b.DecodeRawBytes(true)
 577                 m.TransactionSelector = &CommitRequest_Transaction{x}
 578                 return true, err
 579         default:
 580                 return false, nil
 581         }
 582 }
 583
 584 func _CommitRequest_OneofSizer(msg proto.Message) (n int) {
 585         m := msg.(*CommitRequest)
 586         // transaction_selector
 587         switch x := m.TransactionSelector.(type) {
 588         case *CommitRequest_Transaction:
 589                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
 590                 n += proto.SizeVarint(uint64(len(x.Transaction)))
 591                 n += len(x.Transaction)
 592         case nil:
 593         default:
 594                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 595         }
 596         return n
 597 }
 598
 599 // The response for [Datastore.Commit][google.datastore.v1.Datastore.Commit].
 600 type CommitResponse struct {
 601         // The result of performing the mutations.
 602         // The i-th mutation result corresponds to the i-th mutation in the request.
 603         MutationResults []*MutationResult `protobuf:"bytes,3,rep,name=mutation_results,json=mutationResults" json:"mutation_results,omitempty"`
 604         // The number of index entries updated during the commit, or zero if none were
 605         // updated.
 606         IndexUpdates int32 `protobuf:"varint,4,opt,name=index_updates,json=indexUpdates" json:"index_updates,omitempty"`
 607 }
 608
 609 func (m *CommitResponse) Reset()                    { *m = CommitResponse{} }
 610 func (m *CommitResponse) String() string            { return proto.CompactTextString(m) }
 611 func (*CommitResponse) ProtoMessage()               {}
 612 func (*CommitResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
 613
 614 func (m *CommitResponse) GetMutationResults() []*MutationResult {
 615         if m != nil {
 616                 return m.MutationResults
 617         }
 618         return nil
 619 }
 620
 621 func (m *CommitResponse) GetIndexUpdates() int32 {
 622         if m != nil {
 623                 return m.IndexUpdates
 624         }
 625         return 0
 626 }
 627
 628 // The request for [Datastore.AllocateIds][google.datastore.v1.Datastore.AllocateIds].
 629 type AllocateIdsRequest struct {
 630         // The ID of the project against which to make the request.
 631         ProjectId string `protobuf:"bytes,8,opt,name=project_id,json=projectId" json:"project_id,omitempty"`
 632         // A list of keys with incomplete key paths for which to allocate IDs.
 633         // No key may be reserved/read-only.
 634         Keys []*Key `protobuf:"bytes,1,rep,name=keys" json:"keys,omitempty"`
 635 }
 636
 637 func (m *AllocateIdsRequest) Reset()                    { *m = AllocateIdsRequest{} }
 638 func (m *AllocateIdsRequest) String() string            { return proto.CompactTextString(m) }
 639 func (*AllocateIdsRequest) ProtoMessage()               {}
 640 func (*AllocateIdsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
 641
 642 func (m *AllocateIdsRequest) GetProjectId() string {
 643         if m != nil {
 644                 return m.ProjectId
 645         }
 646         return ""
 647 }
 648
 649 func (m *AllocateIdsRequest) GetKeys() []*Key {
 650         if m != nil {
 651                 return m.Keys
 652         }
 653         return nil
 654 }
 655
 656 // The response for [Datastore.AllocateIds][google.datastore.v1.Datastore.AllocateIds].
 657 type AllocateIdsResponse struct {
 658         // The keys specified in the request (in the same order), each with
 659         // its key path completed with a newly allocated ID.
 660         Keys []*Key `protobuf:"bytes,1,rep,name=keys" json:"keys,omitempty"`
 661 }
 662
 663 func (m *AllocateIdsResponse) Reset()                    { *m = AllocateIdsResponse{} }
 664 func (m *AllocateIdsResponse) String() string            { return proto.CompactTextString(m) }
 665 func (*AllocateIdsResponse) ProtoMessage()               {}
 666 func (*AllocateIdsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
 667
 668 func (m *AllocateIdsResponse) GetKeys() []*Key {
 669         if m != nil {
 670                 return m.Keys
 671         }
 672         return nil
 673 }
 674
 675 // A mutation to apply to an entity.
 676 type Mutation struct {
 677         // The mutation operation.
 678         //
 679         // For `insert`, `update`, and `upsert`:
 680         // - The entity's key must not be reserved/read-only.
 681         // - No property in the entity may have a reserved name,
 682         //   not even a property in an entity in a value.
 683         // - No value in the entity may have meaning 18,
 684         //   not even a value in an entity in another value.
 685         //
 686         // Types that are valid to be assigned to Operation:
 687         //      *Mutation_Insert
 688         //      *Mutation_Update
 689         //      *Mutation_Upsert
 690         //      *Mutation_Delete
 691         Operation isMutation_Operation `protobuf_oneof:"operation"`
 692         // When set, the server will detect whether or not this mutation conflicts
 693         // with the current version of the entity on the server. Conflicting mutations
 694         // are not applied, and are marked as such in MutationResult.
 695         //
 696         // Types that are valid to be assigned to ConflictDetectionStrategy:
 697         //      *Mutation_BaseVersion
 698         ConflictDetectionStrategy isMutation_ConflictDetectionStrategy `protobuf_oneof:"conflict_detection_strategy"`
 699 }
 700
 701 func (m *Mutation) Reset()                    { *m = Mutation{} }
 702 func (m *Mutation) String() string            { return proto.CompactTextString(m) }
 703 func (*Mutation) ProtoMessage()               {}
 704 func (*Mutation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
 705
 706 type isMutation_Operation interface {
 707         isMutation_Operation()
 708 }
 709 type isMutation_ConflictDetectionStrategy interface {
 710         isMutation_ConflictDetectionStrategy()
 711 }
 712
 713 type Mutation_Insert struct {
 714         Insert *Entity `protobuf:"bytes,4,opt,name=insert,oneof"`
 715 }
 716 type Mutation_Update struct {
 717         Update *Entity `protobuf:"bytes,5,opt,name=update,oneof"`
 718 }
 719 type Mutation_Upsert struct {
 720         Upsert *Entity `protobuf:"bytes,6,opt,name=upsert,oneof"`
 721 }
 722 type Mutation_Delete struct {
 723         Delete *Key `protobuf:"bytes,7,opt,name=delete,oneof"`
 724 }
 725 type Mutation_BaseVersion struct {
 726         BaseVersion int64 `protobuf:"varint,8,opt,name=base_version,json=baseVersion,oneof"`
 727 }
 728
 729 func (*Mutation_Insert) isMutation_Operation()                      {}
 730 func (*Mutation_Update) isMutation_Operation()                      {}
 731 func (*Mutation_Upsert) isMutation_Operation()                      {}
 732 func (*Mutation_Delete) isMutation_Operation()                      {}
 733 func (*Mutation_BaseVersion) isMutation_ConflictDetectionStrategy() {}
 734
 735 func (m *Mutation) GetOperation() isMutation_Operation {
 736         if m != nil {
 737                 return m.Operation
 738         }
 739         return nil
 740 }
 741 func (m *Mutation) GetConflictDetectionStrategy() isMutation_ConflictDetectionStrategy {
 742         if m != nil {
 743                 return m.ConflictDetectionStrategy
 744         }
 745         return nil
 746 }
 747
 748 func (m *Mutation) GetInsert() *Entity {
 749         if x, ok := m.GetOperation().(*Mutation_Insert); ok {
 750                 return x.Insert
 751         }
 752         return nil
 753 }
 754
 755 func (m *Mutation) GetUpdate() *Entity {
 756         if x, ok := m.GetOperation().(*Mutation_Update); ok {
 757                 return x.Update
 758         }
 759         return nil
 760 }
 761
 762 func (m *Mutation) GetUpsert() *Entity {
 763         if x, ok := m.GetOperation().(*Mutation_Upsert); ok {
 764                 return x.Upsert
 765         }
 766         return nil
 767 }
 768
 769 func (m *Mutation) GetDelete() *Key {
 770         if x, ok := m.GetOperation().(*Mutation_Delete); ok {
 771                 return x.Delete
 772         }
 773         return nil
 774 }
 775
 776 func (m *Mutation) GetBaseVersion() int64 {
 777         if x, ok := m.GetConflictDetectionStrategy().(*Mutation_BaseVersion); ok {
 778                 return x.BaseVersion
 779         }
 780         return 0
 781 }
 782
 783 // XXX_OneofFuncs is for the internal use of the proto package.
 784 func (*Mutation) 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{}) {
 785         return _Mutation_OneofMarshaler, _Mutation_OneofUnmarshaler, _Mutation_OneofSizer, []interface{}{
 786                 (*Mutation_Insert)(nil),
 787                 (*Mutation_Update)(nil),
 788                 (*Mutation_Upsert)(nil),
 789                 (*Mutation_Delete)(nil),
 790                 (*Mutation_BaseVersion)(nil),
 791         }
 792 }
 793
 794 func _Mutation_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 795         m := msg.(*Mutation)
 796         // operation
 797         switch x := m.Operation.(type) {
 798         case *Mutation_Insert:
 799                 b.EncodeVarint(4<<3 | proto.WireBytes)
 800                 if err := b.EncodeMessage(x.Insert); err != nil {
 801                         return err
 802                 }
 803         case *Mutation_Update:
 804                 b.EncodeVarint(5<<3 | proto.WireBytes)
 805                 if err := b.EncodeMessage(x.Update); err != nil {
 806                         return err
 807                 }
 808         case *Mutation_Upsert:
 809                 b.EncodeVarint(6<<3 | proto.WireBytes)
 810                 if err := b.EncodeMessage(x.Upsert); err != nil {
 811                         return err
 812                 }
 813         case *Mutation_Delete:
 814                 b.EncodeVarint(7<<3 | proto.WireBytes)
 815                 if err := b.EncodeMessage(x.Delete); err != nil {
 816                         return err
 817                 }
 818         case nil:
 819         default:
 820                 return fmt.Errorf("Mutation.Operation has unexpected type %T", x)
 821         }
 822         // conflict_detection_strategy
 823         switch x := m.ConflictDetectionStrategy.(type) {
 824         case *Mutation_BaseVersion:
 825                 b.EncodeVarint(8<<3 | proto.WireVarint)
 826                 b.EncodeVarint(uint64(x.BaseVersion))
 827         case nil:
 828         default:
 829                 return fmt.Errorf("Mutation.ConflictDetectionStrategy has unexpected type %T", x)
 830         }
 831         return nil
 832 }
 833
 834 func _Mutation_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 835         m := msg.(*Mutation)
 836         switch tag {
 837         case 4: // operation.insert
 838                 if wire != proto.WireBytes {
 839                         return true, proto.ErrInternalBadWireType
 840                 }
 841                 msg := new(Entity)
 842                 err := b.DecodeMessage(msg)
 843                 m.Operation = &Mutation_Insert{msg}
 844                 return true, err
 845         case 5: // operation.update
 846                 if wire != proto.WireBytes {
 847                         return true, proto.ErrInternalBadWireType
 848                 }
 849                 msg := new(Entity)
 850                 err := b.DecodeMessage(msg)
 851                 m.Operation = &Mutation_Update{msg}
 852                 return true, err
 853         case 6: // operation.upsert
 854                 if wire != proto.WireBytes {
 855                         return true, proto.ErrInternalBadWireType
 856                 }
 857                 msg := new(Entity)
 858                 err := b.DecodeMessage(msg)
 859                 m.Operation = &Mutation_Upsert{msg}
 860                 return true, err
 861         case 7: // operation.delete
 862                 if wire != proto.WireBytes {
 863                         return true, proto.ErrInternalBadWireType
 864                 }
 865                 msg := new(Key)
 866                 err := b.DecodeMessage(msg)
 867                 m.Operation = &Mutation_Delete{msg}
 868                 return true, err
 869         case 8: // conflict_detection_strategy.base_version
 870                 if wire != proto.WireVarint {
 871                         return true, proto.ErrInternalBadWireType
 872                 }
 873                 x, err := b.DecodeVarint()
 874                 m.ConflictDetectionStrategy = &Mutation_BaseVersion{int64(x)}
 875                 return true, err
 876         default:
 877                 return false, nil
 878         }
 879 }
 880
 881 func _Mutation_OneofSizer(msg proto.Message) (n int) {
 882         m := msg.(*Mutation)
 883         // operation
 884         switch x := m.Operation.(type) {
 885         case *Mutation_Insert:
 886                 s := proto.Size(x.Insert)
 887                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
 888                 n += proto.SizeVarint(uint64(s))
 889                 n += s
 890         case *Mutation_Update:
 891                 s := proto.Size(x.Update)
 892                 n += proto.SizeVarint(5<<3 | proto.WireBytes)
 893                 n += proto.SizeVarint(uint64(s))
 894                 n += s
 895         case *Mutation_Upsert:
 896                 s := proto.Size(x.Upsert)
 897                 n += proto.SizeVarint(6<<3 | proto.WireBytes)
 898                 n += proto.SizeVarint(uint64(s))
 899                 n += s
 900         case *Mutation_Delete:
 901                 s := proto.Size(x.Delete)
 902                 n += proto.SizeVarint(7<<3 | proto.WireBytes)
 903                 n += proto.SizeVarint(uint64(s))
 904                 n += s
 905         case nil:
 906         default:
 907                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 908         }
 909         // conflict_detection_strategy
 910         switch x := m.ConflictDetectionStrategy.(type) {
 911         case *Mutation_BaseVersion:
 912                 n += proto.SizeVarint(8<<3 | proto.WireVarint)
 913                 n += proto.SizeVarint(uint64(x.BaseVersion))
 914         case nil:
 915         default:
 916                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 917         }
 918         return n
 919 }
 920
 921 // The result of applying a mutation.
 922 type MutationResult struct {
 923         // The automatically allocated key.
 924         // Set only when the mutation allocated a key.
 925         Key *Key `protobuf:"bytes,3,opt,name=key" json:"key,omitempty"`
 926         // The version of the entity on the server after processing the mutation. If
 927         // the mutation doesn't change anything on the server, then the version will
 928         // be the version of the current entity or, if no entity is present, a version
 929         // that is strictly greater than the version of any previous entity and less
 930         // than the version of any possible future entity.
 931         Version int64 `protobuf:"varint,4,opt,name=version" json:"version,omitempty"`
 932         // Whether a conflict was detected for this mutation. Always false when a
 933         // conflict detection strategy field is not set in the mutation.
 934         ConflictDetected bool `protobuf:"varint,5,opt,name=conflict_detected,json=conflictDetected" json:"conflict_detected,omitempty"`
 935 }
 936
 937 func (m *MutationResult) Reset()                    { *m = MutationResult{} }
 938 func (m *MutationResult) String() string            { return proto.CompactTextString(m) }
 939 func (*MutationResult) ProtoMessage()               {}
 940 func (*MutationResult) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
 941
 942 func (m *MutationResult) GetKey() *Key {
 943         if m != nil {
 944                 return m.Key
 945         }
 946         return nil
 947 }
 948
 949 func (m *MutationResult) GetVersion() int64 {
 950         if m != nil {
 951                 return m.Version
 952         }
 953         return 0
 954 }
 955
 956 func (m *MutationResult) GetConflictDetected() bool {
 957         if m != nil {
 958                 return m.ConflictDetected
 959         }
 960         return false
 961 }
 962
 963 // The options shared by read requests.
 964 type ReadOptions struct {
 965         // If not specified, lookups and ancestor queries default to
 966         // `read_consistency`=`STRONG`, global queries default to
 967         // `read_consistency`=`EVENTUAL`.
 968         //
 969         // Types that are valid to be assigned to ConsistencyType:
 970         //      *ReadOptions_ReadConsistency_
 971         //      *ReadOptions_Transaction
 972         ConsistencyType isReadOptions_ConsistencyType `protobuf_oneof:"consistency_type"`
 973 }
 974
 975 func (m *ReadOptions) Reset()                    { *m = ReadOptions{} }
 976 func (m *ReadOptions) String() string            { return proto.CompactTextString(m) }
 977 func (*ReadOptions) ProtoMessage()               {}
 978 func (*ReadOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
 979
 980 type isReadOptions_ConsistencyType interface {
 981         isReadOptions_ConsistencyType()
 982 }
 983
 984 type ReadOptions_ReadConsistency_ struct {
 985         ReadConsistency ReadOptions_ReadConsistency `protobuf:"varint,1,opt,name=read_consistency,json=readConsistency,enum=google.datastore.v1.ReadOptions_ReadConsistency,oneof"`
 986 }
 987 type ReadOptions_Transaction struct {
 988         Transaction []byte `protobuf:"bytes,2,opt,name=transaction,proto3,oneof"`
 989 }
 990
 991 func (*ReadOptions_ReadConsistency_) isReadOptions_ConsistencyType() {}
 992 func (*ReadOptions_Transaction) isReadOptions_ConsistencyType()      {}
 993
 994 func (m *ReadOptions) GetConsistencyType() isReadOptions_ConsistencyType {
 995         if m != nil {
 996                 return m.ConsistencyType
 997         }
 998         return nil
 999 }
1000
1001 func (m *ReadOptions) GetReadConsistency() ReadOptions_ReadConsistency {
1002         if x, ok := m.GetConsistencyType().(*ReadOptions_ReadConsistency_); ok {
1003                 return x.ReadConsistency
1004         }
1005         return ReadOptions_READ_CONSISTENCY_UNSPECIFIED
1006 }
1007
1008 func (m *ReadOptions) GetTransaction() []byte {
1009         if x, ok := m.GetConsistencyType().(*ReadOptions_Transaction); ok {
1010                 return x.Transaction
1011         }
1012         return nil
1013 }
1014
1015 // XXX_OneofFuncs is for the internal use of the proto package.
1016 func (*ReadOptions) 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{}) {
1017         return _ReadOptions_OneofMarshaler, _ReadOptions_OneofUnmarshaler, _ReadOptions_OneofSizer, []interface{}{
1018                 (*ReadOptions_ReadConsistency_)(nil),
1019                 (*ReadOptions_Transaction)(nil),
1020         }
1021 }
1022
1023 func _ReadOptions_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
1024         m := msg.(*ReadOptions)
1025         // consistency_type
1026         switch x := m.ConsistencyType.(type) {
1027         case *ReadOptions_ReadConsistency_:
1028                 b.EncodeVarint(1<<3 | proto.WireVarint)
1029                 b.EncodeVarint(uint64(x.ReadConsistency))
1030         case *ReadOptions_Transaction:
1031                 b.EncodeVarint(2<<3 | proto.WireBytes)
1032                 b.EncodeRawBytes(x.Transaction)
1033         case nil:
1034         default:
1035                 return fmt.Errorf("ReadOptions.ConsistencyType has unexpected type %T", x)
1036         }
1037         return nil
1038 }
1039
1040 func _ReadOptions_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
1041         m := msg.(*ReadOptions)
1042         switch tag {
1043         case 1: // consistency_type.read_consistency
1044                 if wire != proto.WireVarint {
1045                         return true, proto.ErrInternalBadWireType
1046                 }
1047                 x, err := b.DecodeVarint()
1048                 m.ConsistencyType = &ReadOptions_ReadConsistency_{ReadOptions_ReadConsistency(x)}
1049                 return true, err
1050         case 2: // consistency_type.transaction
1051                 if wire != proto.WireBytes {
1052                         return true, proto.ErrInternalBadWireType
1053                 }
1054                 x, err := b.DecodeRawBytes(true)
1055                 m.ConsistencyType = &ReadOptions_Transaction{x}
1056                 return true, err
1057         default:
1058                 return false, nil
1059         }
1060 }
1061
1062 func _ReadOptions_OneofSizer(msg proto.Message) (n int) {
1063         m := msg.(*ReadOptions)
1064         // consistency_type
1065         switch x := m.ConsistencyType.(type) {
1066         case *ReadOptions_ReadConsistency_:
1067                 n += proto.SizeVarint(1<<3 | proto.WireVarint)
1068                 n += proto.SizeVarint(uint64(x.ReadConsistency))
1069         case *ReadOptions_Transaction:
1070                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
1071                 n += proto.SizeVarint(uint64(len(x.Transaction)))
1072                 n += len(x.Transaction)
1073         case nil:
1074         default:
1075                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
1076         }
1077         return n
1078 }
1079
1080 // Options for beginning a new transaction.
1081 type TransactionOptions struct {
1082         // The `mode` of the transaction, indicating whether write operations are
1083         // supported.
1084         //
1085         // Types that are valid to be assigned to Mode:
1086         //      *TransactionOptions_ReadWrite_
1087         //      *TransactionOptions_ReadOnly_
1088         Mode isTransactionOptions_Mode `protobuf_oneof:"mode"`
1089 }
1090
1091 func (m *TransactionOptions) Reset()                    { *m = TransactionOptions{} }
1092 func (m *TransactionOptions) String() string            { return proto.CompactTextString(m) }
1093 func (*TransactionOptions) ProtoMessage()               {}
1094 func (*TransactionOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
1095
1096 type isTransactionOptions_Mode interface {
1097         isTransactionOptions_Mode()
1098 }
1099
1100 type TransactionOptions_ReadWrite_ struct {
1101         ReadWrite *TransactionOptions_ReadWrite `protobuf:"bytes,1,opt,name=read_write,json=readWrite,oneof"`
1102 }
1103 type TransactionOptions_ReadOnly_ struct {
1104         ReadOnly *TransactionOptions_ReadOnly `protobuf:"bytes,2,opt,name=read_only,json=readOnly,oneof"`
1105 }
1106
1107 func (*TransactionOptions_ReadWrite_) isTransactionOptions_Mode() {}
1108 func (*TransactionOptions_ReadOnly_) isTransactionOptions_Mode()  {}
1109
1110 func (m *TransactionOptions) GetMode() isTransactionOptions_Mode {
1111         if m != nil {
1112                 return m.Mode
1113         }
1114         return nil
1115 }
1116
1117 func (m *TransactionOptions) GetReadWrite() *TransactionOptions_ReadWrite {
1118         if x, ok := m.GetMode().(*TransactionOptions_ReadWrite_); ok {
1119                 return x.ReadWrite
1120         }
1121         return nil
1122 }
1123
1124 func (m *TransactionOptions) GetReadOnly() *TransactionOptions_ReadOnly {
1125         if x, ok := m.GetMode().(*TransactionOptions_ReadOnly_); ok {
1126                 return x.ReadOnly
1127         }
1128         return nil
1129 }
1130
1131 // XXX_OneofFuncs is for the internal use of the proto package.
1132 func (*TransactionOptions) 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{}) {
1133         return _TransactionOptions_OneofMarshaler, _TransactionOptions_OneofUnmarshaler, _TransactionOptions_OneofSizer, []interface{}{
1134                 (*TransactionOptions_ReadWrite_)(nil),
1135                 (*TransactionOptions_ReadOnly_)(nil),
1136         }
1137 }
1138
1139 func _TransactionOptions_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
1140         m := msg.(*TransactionOptions)
1141         // mode
1142         switch x := m.Mode.(type) {
1143         case *TransactionOptions_ReadWrite_:
1144                 b.EncodeVarint(1<<3 | proto.WireBytes)
1145                 if err := b.EncodeMessage(x.ReadWrite); err != nil {
1146                         return err
1147                 }
1148         case *TransactionOptions_ReadOnly_:
1149                 b.EncodeVarint(2<<3 | proto.WireBytes)
1150                 if err := b.EncodeMessage(x.ReadOnly); err != nil {
1151                         return err
1152                 }
1153         case nil:
1154         default:
1155                 return fmt.Errorf("TransactionOptions.Mode has unexpected type %T", x)
1156         }
1157         return nil
1158 }
1159
1160 func _TransactionOptions_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
1161         m := msg.(*TransactionOptions)
1162         switch tag {
1163         case 1: // mode.read_write
1164                 if wire != proto.WireBytes {
1165                         return true, proto.ErrInternalBadWireType
1166                 }
1167                 msg := new(TransactionOptions_ReadWrite)
1168                 err := b.DecodeMessage(msg)
1169                 m.Mode = &TransactionOptions_ReadWrite_{msg}
1170                 return true, err
1171         case 2: // mode.read_only
1172                 if wire != proto.WireBytes {
1173                         return true, proto.ErrInternalBadWireType
1174                 }
1175                 msg := new(TransactionOptions_ReadOnly)
1176                 err := b.DecodeMessage(msg)
1177                 m.Mode = &TransactionOptions_ReadOnly_{msg}
1178                 return true, err
1179         default:
1180                 return false, nil
1181         }
1182 }
1183
1184 func _TransactionOptions_OneofSizer(msg proto.Message) (n int) {
1185         m := msg.(*TransactionOptions)
1186         // mode
1187         switch x := m.Mode.(type) {
1188         case *TransactionOptions_ReadWrite_:
1189                 s := proto.Size(x.ReadWrite)
1190                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
1191                 n += proto.SizeVarint(uint64(s))
1192                 n += s
1193         case *TransactionOptions_ReadOnly_:
1194                 s := proto.Size(x.ReadOnly)
1195                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
1196                 n += proto.SizeVarint(uint64(s))
1197                 n += s
1198         case nil:
1199         default:
1200                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
1201         }
1202         return n
1203 }
1204
1205 // Options specific to read / write transactions.
1206 type TransactionOptions_ReadWrite struct {
1207         // The transaction identifier of the transaction being retried.
1208         PreviousTransaction []byte `protobuf:"bytes,1,opt,name=previous_transaction,json=previousTransaction,proto3" json:"previous_transaction,omitempty"`
1209 }
1210
1211 func (m *TransactionOptions_ReadWrite) Reset()         { *m = TransactionOptions_ReadWrite{} }
1212 func (m *TransactionOptions_ReadWrite) String() string { return proto.CompactTextString(m) }
1213 func (*TransactionOptions_ReadWrite) ProtoMessage()    {}
1214 func (*TransactionOptions_ReadWrite) Descriptor() ([]byte, []int) {
1215         return fileDescriptor0, []int{15, 0}
1216 }
1217
1218 func (m *TransactionOptions_ReadWrite) GetPreviousTransaction() []byte {
1219         if m != nil {
1220                 return m.PreviousTransaction
1221         }
1222         return nil
1223 }
1224
1225 // Options specific to read-only transactions.
1226 type TransactionOptions_ReadOnly struct {
1227 }
1228
1229 func (m *TransactionOptions_ReadOnly) Reset()                    { *m = TransactionOptions_ReadOnly{} }
1230 func (m *TransactionOptions_ReadOnly) String() string            { return proto.CompactTextString(m) }
1231 func (*TransactionOptions_ReadOnly) ProtoMessage()               {}
1232 func (*TransactionOptions_ReadOnly) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15, 1} }
1233
1234 func init() {
1235         proto.RegisterType((*LookupRequest)(nil), "google.datastore.v1.LookupRequest")
1236         proto.RegisterType((*LookupResponse)(nil), "google.datastore.v1.LookupResponse")
1237         proto.RegisterType((*RunQueryRequest)(nil), "google.datastore.v1.RunQueryRequest")
1238         proto.RegisterType((*RunQueryResponse)(nil), "google.datastore.v1.RunQueryResponse")
1239         proto.RegisterType((*BeginTransactionRequest)(nil), "google.datastore.v1.BeginTransactionRequest")
1240         proto.RegisterType((*BeginTransactionResponse)(nil), "google.datastore.v1.BeginTransactionResponse")
1241         proto.RegisterType((*RollbackRequest)(nil), "google.datastore.v1.RollbackRequest")
1242         proto.RegisterType((*RollbackResponse)(nil), "google.datastore.v1.RollbackResponse")
1243         proto.RegisterType((*CommitRequest)(nil), "google.datastore.v1.CommitRequest")
1244         proto.RegisterType((*CommitResponse)(nil), "google.datastore.v1.CommitResponse")
1245         proto.RegisterType((*AllocateIdsRequest)(nil), "google.datastore.v1.AllocateIdsRequest")
1246         proto.RegisterType((*AllocateIdsResponse)(nil), "google.datastore.v1.AllocateIdsResponse")
1247         proto.RegisterType((*Mutation)(nil), "google.datastore.v1.Mutation")
1248         proto.RegisterType((*MutationResult)(nil), "google.datastore.v1.MutationResult")
1249         proto.RegisterType((*ReadOptions)(nil), "google.datastore.v1.ReadOptions")
1250         proto.RegisterType((*TransactionOptions)(nil), "google.datastore.v1.TransactionOptions")
1251         proto.RegisterType((*TransactionOptions_ReadWrite)(nil), "google.datastore.v1.TransactionOptions.ReadWrite")
1252         proto.RegisterType((*TransactionOptions_ReadOnly)(nil), "google.datastore.v1.TransactionOptions.ReadOnly")
1253         proto.RegisterEnum("google.datastore.v1.CommitRequest_Mode", CommitRequest_Mode_name, CommitRequest_Mode_value)
1254         proto.RegisterEnum("google.datastore.v1.ReadOptions_ReadConsistency", ReadOptions_ReadConsistency_name, ReadOptions_ReadConsistency_value)
1255 }
1256
1257 // Reference imports to suppress errors if they are not otherwise used.
1258 var _ context.Context
1259 var _ grpc.ClientConn
1260
1261 // This is a compile-time assertion to ensure that this generated file
1262 // is compatible with the grpc package it is being compiled against.
1263 const _ = grpc.SupportPackageIsVersion4
1264
1265 // Client API for Datastore service
1266
1267 type DatastoreClient interface {
1268         // Looks up entities by key.
1269         Lookup(ctx context.Context, in *LookupRequest, opts ...grpc.CallOption) (*LookupResponse, error)
1270         // Queries for entities.
1271         RunQuery(ctx context.Context, in *RunQueryRequest, opts ...grpc.CallOption) (*RunQueryResponse, error)
1272         // Begins a new transaction.
1273         BeginTransaction(ctx context.Context, in *BeginTransactionRequest, opts ...grpc.CallOption) (*BeginTransactionResponse, error)
1274         // Commits a transaction, optionally creating, deleting or modifying some
1275         // entities.
1276         Commit(ctx context.Context, in *CommitRequest, opts ...grpc.CallOption) (*CommitResponse, error)
1277         // Rolls back a transaction.
1278         Rollback(ctx context.Context, in *RollbackRequest, opts ...grpc.CallOption) (*RollbackResponse, error)
1279         // Allocates IDs for the given keys, which is useful for referencing an entity
1280         // before it is inserted.
1281         AllocateIds(ctx context.Context, in *AllocateIdsRequest, opts ...grpc.CallOption) (*AllocateIdsResponse, error)
1282 }
1283
1284 type datastoreClient struct {
1285         cc *grpc.ClientConn
1286 }
1287
1288 func NewDatastoreClient(cc *grpc.ClientConn) DatastoreClient {
1289         return &datastoreClient{cc}
1290 }
1291
1292 func (c *datastoreClient) Lookup(ctx context.Context, in *LookupRequest, opts ...grpc.CallOption) (*LookupResponse, error) {
1293         out := new(LookupResponse)
1294         err := grpc.Invoke(ctx, "/google.datastore.v1.Datastore/Lookup", in, out, c.cc, opts...)
1295         if err != nil {
1296                 return nil, err
1297         }
1298         return out, nil
1299 }
1300
1301 func (c *datastoreClient) RunQuery(ctx context.Context, in *RunQueryRequest, opts ...grpc.CallOption) (*RunQueryResponse, error) {
1302         out := new(RunQueryResponse)
1303         err := grpc.Invoke(ctx, "/google.datastore.v1.Datastore/RunQuery", in, out, c.cc, opts...)
1304         if err != nil {
1305                 return nil, err
1306         }
1307         return out, nil
1308 }
1309
1310 func (c *datastoreClient) BeginTransaction(ctx context.Context, in *BeginTransactionRequest, opts ...grpc.CallOption) (*BeginTransactionResponse, error) {
1311         out := new(BeginTransactionResponse)
1312         err := grpc.Invoke(ctx, "/google.datastore.v1.Datastore/BeginTransaction", in, out, c.cc, opts...)
1313         if err != nil {
1314                 return nil, err
1315         }
1316         return out, nil
1317 }
1318
1319 func (c *datastoreClient) Commit(ctx context.Context, in *CommitRequest, opts ...grpc.CallOption) (*CommitResponse, error) {
1320         out := new(CommitResponse)
1321         err := grpc.Invoke(ctx, "/google.datastore.v1.Datastore/Commit", in, out, c.cc, opts...)
1322         if err != nil {
1323                 return nil, err
1324         }
1325         return out, nil
1326 }
1327
1328 func (c *datastoreClient) Rollback(ctx context.Context, in *RollbackRequest, opts ...grpc.CallOption) (*RollbackResponse, error) {
1329         out := new(RollbackResponse)
1330         err := grpc.Invoke(ctx, "/google.datastore.v1.Datastore/Rollback", in, out, c.cc, opts...)
1331         if err != nil {
1332                 return nil, err
1333         }
1334         return out, nil
1335 }
1336
1337 func (c *datastoreClient) AllocateIds(ctx context.Context, in *AllocateIdsRequest, opts ...grpc.CallOption) (*AllocateIdsResponse, error) {
1338         out := new(AllocateIdsResponse)
1339         err := grpc.Invoke(ctx, "/google.datastore.v1.Datastore/AllocateIds", in, out, c.cc, opts...)
1340         if err != nil {
1341                 return nil, err
1342         }
1343         return out, nil
1344 }
1345
1346 // Server API for Datastore service
1347
1348 type DatastoreServer interface {
1349         // Looks up entities by key.
1350         Lookup(context.Context, *LookupRequest) (*LookupResponse, error)
1351         // Queries for entities.
1352         RunQuery(context.Context, *RunQueryRequest) (*RunQueryResponse, error)
1353         // Begins a new transaction.
1354         BeginTransaction(context.Context, *BeginTransactionRequest) (*BeginTransactionResponse, error)
1355         // Commits a transaction, optionally creating, deleting or modifying some
1356         // entities.
1357         Commit(context.Context, *CommitRequest) (*CommitResponse, error)
1358         // Rolls back a transaction.
1359         Rollback(context.Context, *RollbackRequest) (*RollbackResponse, error)
1360         // Allocates IDs for the given keys, which is useful for referencing an entity
1361         // before it is inserted.
1362         AllocateIds(context.Context, *AllocateIdsRequest) (*AllocateIdsResponse, error)
1363 }
1364
1365 func RegisterDatastoreServer(s *grpc.Server, srv DatastoreServer) {
1366         s.RegisterService(&_Datastore_serviceDesc, srv)
1367 }
1368
1369 func _Datastore_Lookup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1370         in := new(LookupRequest)
1371         if err := dec(in); err != nil {
1372                 return nil, err
1373         }
1374         if interceptor == nil {
1375                 return srv.(DatastoreServer).Lookup(ctx, in)
1376         }
1377         info := &grpc.UnaryServerInfo{
1378                 Server:     srv,
1379                 FullMethod: "/google.datastore.v1.Datastore/Lookup",
1380         }
1381         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1382                 return srv.(DatastoreServer).Lookup(ctx, req.(*LookupRequest))
1383         }
1384         return interceptor(ctx, in, info, handler)
1385 }
1386
1387 func _Datastore_RunQuery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1388         in := new(RunQueryRequest)
1389         if err := dec(in); err != nil {
1390                 return nil, err
1391         }
1392         if interceptor == nil {
1393                 return srv.(DatastoreServer).RunQuery(ctx, in)
1394         }
1395         info := &grpc.UnaryServerInfo{
1396                 Server:     srv,
1397                 FullMethod: "/google.datastore.v1.Datastore/RunQuery",
1398         }
1399         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1400                 return srv.(DatastoreServer).RunQuery(ctx, req.(*RunQueryRequest))
1401         }
1402         return interceptor(ctx, in, info, handler)
1403 }
1404
1405 func _Datastore_BeginTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1406         in := new(BeginTransactionRequest)
1407         if err := dec(in); err != nil {
1408                 return nil, err
1409         }
1410         if interceptor == nil {
1411                 return srv.(DatastoreServer).BeginTransaction(ctx, in)
1412         }
1413         info := &grpc.UnaryServerInfo{
1414                 Server:     srv,
1415                 FullMethod: "/google.datastore.v1.Datastore/BeginTransaction",
1416         }
1417         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1418                 return srv.(DatastoreServer).BeginTransaction(ctx, req.(*BeginTransactionRequest))
1419         }
1420         return interceptor(ctx, in, info, handler)
1421 }
1422
1423 func _Datastore_Commit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1424         in := new(CommitRequest)
1425         if err := dec(in); err != nil {
1426                 return nil, err
1427         }
1428         if interceptor == nil {
1429                 return srv.(DatastoreServer).Commit(ctx, in)
1430         }
1431         info := &grpc.UnaryServerInfo{
1432                 Server:     srv,
1433                 FullMethod: "/google.datastore.v1.Datastore/Commit",
1434         }
1435         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1436                 return srv.(DatastoreServer).Commit(ctx, req.(*CommitRequest))
1437         }
1438         return interceptor(ctx, in, info, handler)
1439 }
1440
1441 func _Datastore_Rollback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1442         in := new(RollbackRequest)
1443         if err := dec(in); err != nil {
1444                 return nil, err
1445         }
1446         if interceptor == nil {
1447                 return srv.(DatastoreServer).Rollback(ctx, in)
1448         }
1449         info := &grpc.UnaryServerInfo{
1450                 Server:     srv,
1451                 FullMethod: "/google.datastore.v1.Datastore/Rollback",
1452         }
1453         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1454                 return srv.(DatastoreServer).Rollback(ctx, req.(*RollbackRequest))
1455         }
1456         return interceptor(ctx, in, info, handler)
1457 }
1458
1459 func _Datastore_AllocateIds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1460         in := new(AllocateIdsRequest)
1461         if err := dec(in); err != nil {
1462                 return nil, err
1463         }
1464         if interceptor == nil {
1465                 return srv.(DatastoreServer).AllocateIds(ctx, in)
1466         }
1467         info := &grpc.UnaryServerInfo{
1468                 Server:     srv,
1469                 FullMethod: "/google.datastore.v1.Datastore/AllocateIds",
1470         }
1471         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1472                 return srv.(DatastoreServer).AllocateIds(ctx, req.(*AllocateIdsRequest))
1473         }
1474         return interceptor(ctx, in, info, handler)
1475 }
1476
1477 var _Datastore_serviceDesc = grpc.ServiceDesc{
1478         ServiceName: "google.datastore.v1.Datastore",
1479         HandlerType: (*DatastoreServer)(nil),
1480         Methods: []grpc.MethodDesc{
1481                 {
1482                         MethodName: "Lookup",
1483                         Handler:    _Datastore_Lookup_Handler,
1484                 },
1485                 {
1486                         MethodName: "RunQuery",
1487                         Handler:    _Datastore_RunQuery_Handler,
1488                 },
1489                 {
1490                         MethodName: "BeginTransaction",
1491                         Handler:    _Datastore_BeginTransaction_Handler,
1492                 },
1493                 {
1494                         MethodName: "Commit",
1495                         Handler:    _Datastore_Commit_Handler,
1496                 },
1497                 {
1498                         MethodName: "Rollback",
1499                         Handler:    _Datastore_Rollback_Handler,
1500                 },
1501                 {
1502                         MethodName: "AllocateIds",
1503                         Handler:    _Datastore_AllocateIds_Handler,
1504                 },
1505         },
1506         Streams:  []grpc.StreamDesc{},
1507         Metadata: "google/datastore/v1/datastore.proto",
1508 }
1509
1510 func init() { proto.RegisterFile("google/datastore/v1/datastore.proto", fileDescriptor0) }
1511
1512 var fileDescriptor0 = []byte{
1513         // 1312 bytes of a gzipped FileDescriptorProto
1514         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x5f, 0x6f, 0xdb, 0x54,
1515         0x14, 0xef, 0x4d, 0xdb, 0x2c, 0x39, 0xe9, 0x9f, 0xec, 0x76, 0xb0, 0x90, 0x6d, 0x22, 0xb8, 0x54,
1516         0xab, 0xba, 0x2d, 0x69, 0x03, 0x13, 0xd2, 0x3a, 0x21, 0x35, 0x69, 0xb6, 0x46, 0xac, 0x49, 0xb9,
1517         0xed, 0xc6, 0x1f, 0x09, 0x45, 0xae, 0x7d, 0x1b, 0x4c, 0x1d, 0x5f, 0xd7, 0xbe, 0x29, 0x44, 0x88,
1518         0x49, 0x80, 0xc6, 0x1b, 0x2f, 0xe3, 0x13, 0xf0, 0xc2, 0x03, 0xe2, 0x91, 0x27, 0xc4, 0xb7, 0xe0,
1519         0x91, 0x57, 0xbe, 0x01, 0x5f, 0x00, 0xf9, 0xfa, 0x3a, 0x89, 0x53, 0xbb, 0xf1, 0x24, 0xde, 0x7c,
1520         0xaf, 0x7f, 0xbf, 0x73, 0x7e, 0xe7, 0x9c, 0xeb, 0x73, 0xae, 0x61, 0xb5, 0xcb, 0x58, 0xd7, 0xa4,
1521         0x15, 0x5d, 0xe5, 0xaa, 0xcb, 0x99, 0x43, 0x2b, 0xe7, 0x5b, 0xa3, 0x45, 0xd9, 0x76, 0x18, 0x67,
1522         0x78, 0xc5, 0x07, 0x95, 0x47, 0xfb, 0xe7, 0x5b, 0xc5, 0x9b, 0x92, 0xa9, 0xda, 0x46, 0x45, 0xb5,
1523         0x2c, 0xc6, 0x55, 0x6e, 0x30, 0xcb, 0xf5, 0x29, 0xc5, 0x52, 0x94, 0x5d, 0x6a, 0x71, 0x83, 0x0f,
1524         0x24, 0xe2, 0xcd, 0x28, 0xc4, 0x59, 0x9f, 0x3a, 0x12, 0xa0, 0xfc, 0x8c, 0x60, 0xf1, 0x09, 0x63,
1525         0xa7, 0x7d, 0x9b, 0xd0, 0xb3, 0x3e, 0x75, 0x39, 0xbe, 0x05, 0x60, 0x3b, 0xec, 0x0b, 0xaa, 0xf1,
1526         0x8e, 0xa1, 0x17, 0x32, 0x25, 0xb4, 0x9e, 0x25, 0x59, 0xb9, 0xd3, 0xd4, 0x71, 0x1d, 0x16, 0x1c,
1527         0xaa, 0xea, 0x1d, 0x66, 0x0b, 0x25, 0x05, 0x54, 0x42, 0xeb, 0xb9, 0x6a, 0xa9, 0x1c, 0xa1, 0xbe,
1528         0x4c, 0xa8, 0xaa, 0xb7, 0x7d, 0x1c, 0xc9, 0x39, 0xa3, 0x05, 0xbe, 0x0b, 0x73, 0xa7, 0x74, 0xe0,
1529         0x16, 0x66, 0x4b, 0xb3, 0xeb, 0xb9, 0x6a, 0x21, 0x92, 0xfc, 0x01, 0x1d, 0x10, 0x81, 0x52, 0xfe,
1530         0x44, 0xb0, 0x14, 0x68, 0x74, 0x6d, 0x66, 0xb9, 0x14, 0xbf, 0x07, 0xf3, 0x27, 0xac, 0x6f, 0xe9,
1531         0x05, 0x24, 0x2c, 0xbc, 0x15, 0x69, 0xa1, 0x21, 0x32, 0x41, 0xa8, 0xdb, 0x37, 0x39, 0xf1, 0xf1,
1532         0x78, 0x1b, 0xae, 0xf4, 0x0c, 0xd7, 0x35, 0xac, 0x6e, 0x21, 0x95, 0x94, 0x1a, 0x30, 0xf0, 0xbb,
1533         0x90, 0xd1, 0xe9, 0x09, 0x75, 0x1c, 0xaa, 0x4f, 0x95, 0x3e, 0x44, 0x2a, 0x7f, 0xa4, 0x60, 0x99,
1534         0xf4, 0xad, 0x0f, 0xbd, 0xac, 0x27, 0x4f, 0xb2, 0xad, 0x3a, 0xdc, 0xf0, 0xb2, 0xe5, 0x01, 0x52,
1535         0x97, 0x24, 0xf9, 0x20, 0x00, 0x36, 0x75, 0x92, 0xb3, 0x47, 0x8b, 0xff, 0xa7, 0x52, 0x55, 0x98,
1536         0x17, 0xc7, 0xa5, 0x30, 0x2b, 0xd8, 0xc5, 0x48, 0xb6, 0x08, 0x6d, 0x6f, 0x86, 0xf8, 0x50, 0xfc,
1537         0x10, 0xb2, 0xdd, 0x33, 0xb3, 0xe3, 0xf3, 0xae, 0x08, 0xde, 0xad, 0x48, 0xde, 0xe3, 0x33, 0x33,
1538         0xa0, 0x66, 0xba, 0xf2, 0xb9, 0xb6, 0x00, 0x20, 0x98, 0x1d, 0x3e, 0xb0, 0xa9, 0xf2, 0x2d, 0x82,
1539         0xfc, 0x28, 0x79, 0xb2, 0xfa, 0xdb, 0x30, 0x7f, 0xac, 0x72, 0xed, 0x73, 0x19, 0xd2, 0x5a, 0xbc,
1540         0x28, 0xbf, 0x82, 0x35, 0x0f, 0x4c, 0x7c, 0x0e, 0xde, 0x0c, 0x22, 0x4a, 0x4d, 0x8b, 0x48, 0xc6,
1541         0xa3, 0xbc, 0x44, 0x70, 0xbd, 0x46, 0xbb, 0x86, 0x75, 0xe4, 0xa8, 0x96, 0xab, 0x6a, 0x5e, 0x66,
1542         0x12, 0x16, 0xf2, 0x63, 0x58, 0xe1, 0x23, 0xd2, 0xb0, 0x14, 0x20, 0x5c, 0xdf, 0x8e, 0x74, 0x3d,
1543         0xe6, 0x24, 0xa8, 0x08, 0xe6, 0x17, 0xf6, 0x94, 0x87, 0x50, 0xb8, 0xa8, 0x49, 0xe6, 0xa7, 0x04,
1544         0xb9, 0x31, 0x86, 0xc8, 0xd2, 0x02, 0x19, 0xdf, 0x52, 0x08, 0x2c, 0x13, 0x66, 0x9a, 0xc7, 0xaa,
1545         0x76, 0x9a, 0x30, 0x92, 0xe9, 0x36, 0x31, 0xe4, 0x47, 0x36, 0x7d, 0x25, 0xca, 0x6f, 0x29, 0x58,
1546         0xac, 0xb3, 0x5e, 0xcf, 0xe0, 0x09, 0xdd, 0x6c, 0xc3, 0x5c, 0x8f, 0xe9, 0xb4, 0x30, 0x5f, 0x42,
1547         0xeb, 0x4b, 0x31, 0x19, 0x0a, 0x19, 0x2c, 0xef, 0x33, 0x9d, 0x12, 0x41, 0xc2, 0x4a, 0x84, 0xc6,
1548         0xbd, 0x99, 0x90, 0x4a, 0xbc, 0x0d, 0xd9, 0x5e, 0x5f, 0xb6, 0xd1, 0x42, 0x5a, 0x7c, 0xc4, 0xd1,
1549         0x87, 0x73, 0x5f, 0xa2, 0xc8, 0x08, 0xaf, 0x3c, 0x82, 0x39, 0xcf, 0x1d, 0xbe, 0x06, 0xf9, 0xfd,
1550         0xf6, 0x6e, 0xa3, 0xf3, 0xb4, 0x75, 0x78, 0xd0, 0xa8, 0x37, 0x1f, 0x35, 0x1b, 0xbb, 0xf9, 0x19,
1551         0x7c, 0x15, 0x16, 0x8f, 0xc8, 0x4e, 0xeb, 0x70, 0xa7, 0x7e, 0xd4, 0x6c, 0xb7, 0x76, 0x9e, 0xe4,
1552         0x11, 0x7e, 0x0d, 0xae, 0xb6, 0xda, 0xad, 0x4e, 0x78, 0x3b, 0x55, 0x7b, 0x1d, 0xae, 0x8d, 0x1f,
1553         0x0b, 0x97, 0x9a, 0x54, 0xe3, 0xcc, 0x51, 0x5e, 0x20, 0x58, 0x0a, 0xa2, 0x93, 0xb5, 0x6c, 0x41,
1554         0x3e, 0xf0, 0xdf, 0x71, 0xc4, 0x69, 0x0e, 0xda, 0xe6, 0xea, 0xe5, 0xb2, 0xfd, 0xde, 0xb5, 0xdc,
1555         0x0b, 0xad, 0x5d, 0xbc, 0x0a, 0x8b, 0x86, 0xa5, 0xd3, 0xaf, 0x3a, 0x7d, 0x5b, 0x57, 0x39, 0x75,
1556         0x0b, 0x73, 0x25, 0xb4, 0x3e, 0x4f, 0x16, 0xc4, 0xe6, 0x53, 0x7f, 0x4f, 0x51, 0x01, 0xef, 0x98,
1557         0x26, 0xd3, 0x54, 0x4e, 0x9b, 0xba, 0x9b, 0xb0, 0x74, 0x41, 0x53, 0x47, 0x89, 0x9a, 0x7a, 0x1d,
1558         0x56, 0x42, 0x2e, 0x64, 0xb8, 0xaf, 0x66, 0xe4, 0xf7, 0x14, 0x64, 0x82, 0x80, 0xf1, 0x7d, 0x48,
1559         0x1b, 0x96, 0x4b, 0x1d, 0x2e, 0x42, 0xca, 0x55, 0x6f, 0x5c, 0xd2, 0xd9, 0xf7, 0x66, 0x88, 0x04,
1560         0x7b, 0x34, 0x3f, 0x15, 0xe2, 0xcc, 0x4d, 0xa7, 0xf9, 0x60, 0x9f, 0x26, 0xbc, 0xa5, 0x13, 0xd2,
1561         0x84, 0xb7, 0x2a, 0xa4, 0x75, 0x6a, 0x52, 0x4e, 0x65, 0x63, 0x8c, 0x8d, 0xd0, 0xe3, 0xf8, 0x48,
1562         0xbc, 0x0a, 0x0b, 0xc7, 0xaa, 0x4b, 0x3b, 0xe7, 0xd4, 0x71, 0xbd, 0x73, 0xed, 0x65, 0x7e, 0x76,
1563         0x0f, 0x91, 0x9c, 0xb7, 0xfb, 0xcc, 0xdf, 0xac, 0xe5, 0x20, 0xcb, 0x6c, 0xea, 0x88, 0x54, 0xd4,
1564         0x6e, 0xc1, 0x0d, 0x8d, 0x59, 0x27, 0xa6, 0xa1, 0xf1, 0x8e, 0x4e, 0x39, 0x95, 0xc7, 0x8c, 0x3b,
1565         0x2a, 0xa7, 0xdd, 0x81, 0xf2, 0x3d, 0x82, 0xa5, 0xf0, 0x39, 0xc1, 0x1b, 0x30, 0x7b, 0x4a, 0x83,
1566         0x2e, 0x1f, 0x9f, 0x76, 0x0f, 0x84, 0x0b, 0x70, 0x25, 0x90, 0xe2, 0x65, 0x7a, 0x96, 0x04, 0x4b,
1567         0x7c, 0x07, 0xae, 0x4e, 0xf8, 0xa5, 0xba, 0x48, 0x6b, 0x86, 0xe4, 0x83, 0x17, 0xbb, 0x72, 0x5f,
1568         0xf9, 0x17, 0x41, 0x6e, 0x6c, 0xee, 0xe0, 0xcf, 0x20, 0x2f, 0xe6, 0x95, 0xc6, 0x2c, 0xd7, 0x70,
1569         0x39, 0xb5, 0xb4, 0x81, 0xf8, 0x84, 0x97, 0xaa, 0x9b, 0xd3, 0x66, 0x96, 0x78, 0xae, 0x8f, 0x78,
1570         0x7b, 0x33, 0x64, 0xd9, 0x09, 0x6f, 0x4d, 0x36, 0x87, 0x54, 0x44, 0x73, 0x50, 0xf6, 0x61, 0x79,
1571         0xc2, 0x12, 0x2e, 0xc1, 0x4d, 0xd2, 0xd8, 0xd9, 0xed, 0xd4, 0xdb, 0xad, 0xc3, 0xe6, 0xe1, 0x51,
1572         0xa3, 0x55, 0xff, 0x64, 0xe2, 0xb3, 0x07, 0x48, 0x1f, 0x1e, 0x91, 0x76, 0xeb, 0x71, 0x1e, 0xe1,
1573         0x05, 0xc8, 0x34, 0x9e, 0x35, 0x5a, 0x47, 0x4f, 0xc5, 0x67, 0x8e, 0x21, 0x3f, 0x16, 0x8c, 0x3f,
1574         0xd0, 0x7e, 0x4c, 0x01, 0xbe, 0xd8, 0xe2, 0x31, 0x01, 0x10, 0xc1, 0x7f, 0xe9, 0x18, 0x9c, 0xca,
1575         0xb9, 0xb6, 0x95, 0x70, 0x3e, 0x88, 0xe8, 0x3f, 0xf2, 0x88, 0x7b, 0x33, 0x24, 0xeb, 0x04, 0x0b,
1576         0xdc, 0x86, 0xac, 0x7f, 0x01, 0xb0, 0xcc, 0x60, 0xda, 0x6d, 0xbe, 0x8a, 0xc9, 0xb6, 0x65, 0x8a,
1577         0xd1, 0xec, 0xc8, 0xe7, 0xe2, 0xfb, 0x90, 0x1d, 0xba, 0xc2, 0x5b, 0x70, 0xcd, 0x76, 0xe8, 0xb9,
1578         0xc1, 0xfa, 0x6e, 0xe7, 0xe2, 0x64, 0x58, 0x09, 0xde, 0x8d, 0xd9, 0x2e, 0x02, 0x64, 0x02, 0xbb,
1579         0xb5, 0xb4, 0xdf, 0xe8, 0xab, 0x7f, 0xa7, 0x21, 0xbb, 0x1b, 0x88, 0xc1, 0xcf, 0x21, 0xed, 0xdf,
1580         0xf4, 0xb0, 0x12, 0xa9, 0x34, 0x74, 0x55, 0x2d, 0xae, 0x5e, 0x8a, 0x91, 0x23, 0xe8, 0xce, 0x77,
1581         0x7f, 0xfd, 0xf3, 0x53, 0x6a, 0x4d, 0x29, 0x79, 0x57, 0x5f, 0xd9, 0xad, 0xdc, 0xca, 0xd7, 0xa3,
1582         0x4e, 0xf6, 0xcd, 0x03, 0x53, 0x30, 0x1e, 0xa0, 0x0d, 0xfc, 0x03, 0x82, 0x4c, 0x70, 0xdd, 0xc0,
1583         0x6f, 0x47, 0x1f, 0xbb, 0xf0, 0x55, 0xae, 0xb8, 0x36, 0x05, 0x25, 0x65, 0xdc, 0x13, 0x32, 0x6e,
1584         0x2b, 0x4a, 0xbc, 0x0c, 0x47, 0x72, 0x3c, 0x21, 0xbf, 0x20, 0xc8, 0x4f, 0xce, 0x77, 0x7c, 0x37,
1585         0xd2, 0x55, 0xcc, 0xd5, 0xa4, 0x78, 0x2f, 0x21, 0x5a, 0x0a, 0xbc, 0x2f, 0x04, 0x56, 0x94, 0x8d,
1586         0x78, 0x81, 0xc7, 0x13, 0x5c, 0x4f, 0xe8, 0x73, 0x48, 0xfb, 0x13, 0x2b, 0xa6, 0x62, 0xa1, 0x61,
1587         0x1d, 0x53, 0xb1, 0xf0, 0xc8, 0x4b, 0x52, 0x31, 0x4d, 0x30, 0x86, 0x15, 0x93, 0xd7, 0x8e, 0xb8,
1588         0x8a, 0x85, 0x6f, 0x3a, 0x71, 0x15, 0x9b, 0xbc, 0xbb, 0x24, 0xa9, 0x98, 0xe4, 0x78, 0x42, 0x5e,
1589         0x22, 0xc8, 0x8d, 0x4d, 0x34, 0x1c, 0x7d, 0x77, 0xb9, 0x38, 0x56, 0x8b, 0xeb, 0xd3, 0x81, 0x52,
1590         0xd1, 0xa6, 0x50, 0xb4, 0xa1, 0xac, 0xc5, 0x2b, 0x52, 0x47, 0xb4, 0x07, 0x68, 0xa3, 0xf6, 0x02,
1591         0xc1, 0x75, 0x8d, 0xf5, 0xa2, 0x3c, 0xd4, 0x96, 0x86, 0x9f, 0xdd, 0x81, 0xf7, 0x2b, 0x78, 0x80,
1592         0x3e, 0x7d, 0x28, 0x61, 0x5d, 0x66, 0xaa, 0x56, 0xb7, 0xcc, 0x9c, 0x6e, 0xa5, 0x4b, 0x2d, 0xf1,
1593         0xa3, 0x58, 0xf1, 0x5f, 0xa9, 0xb6, 0xe1, 0x86, 0x7e, 0x26, 0xb7, 0x87, 0x8b, 0x5f, 0x53, 0x6f,
1594         0x3c, 0xf6, 0xe9, 0x75, 0x93, 0xf5, 0xf5, 0xf2, 0xd0, 0x7a, 0xf9, 0xd9, 0xd6, 0x71, 0x5a, 0x18,
1595         0x79, 0xe7, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xb7, 0x0f, 0xc7, 0x4b, 0x0a, 0x0f, 0x00, 0x00,
1596 }