Documentation

Overview

Package datastore provides access to the Cloud Datastore API.

This package is DEPRECATED. Use package cloud.google.com/go/datastore instead.

For product documentation, see: https://cloud.google.com/datastore/

Creating a client

Usage example:

import "google.golang.org/api/datastore/v1beta3"
...
ctx := context.Background()
datastoreService, err := datastore.NewService(ctx)

In this example, Google Application Default Credentials are used for authentication.

For information on how to create and obtain Application Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials.

Other authentication options

By default, all available scopes (see "Constants") are used to authenticate. To restrict scopes, use option.WithScopes:

datastoreService, err := datastore.NewService(ctx, option.WithScopes(datastore.DatastoreScope))

To use an API key for authentication (note: some APIs do not support API keys), use option.WithAPIKey:

datastoreService, err := datastore.NewService(ctx, option.WithAPIKey("AIza..."))

To use an OAuth token (e.g., a user token obtained via a three-legged OAuth flow), use option.WithTokenSource:

config := &oauth2.Config{...}
// ...
token, err := config.Exchange(ctx, ...)
datastoreService, err := datastore.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token)))

See https://godoc.org/google.golang.org/api/option/ for details on options.

Index

Constants

View Source
const (
	// View and manage your data across Google Cloud Platform services
	CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"

	// View and manage your Google Cloud Datastore data
	DatastoreScope = "https://www.googleapis.com/auth/datastore"
)

    OAuth2 scopes used by this API.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type AllocateIdsRequest

    type AllocateIdsRequest struct {
    	// Keys: Required. A list of keys with incomplete key paths for which to
    	// allocate IDs. No key may be reserved/read-only.
    	Keys []*Key `json:"keys,omitempty"`
    
    	// ForceSendFields is a list of field names (e.g. "Keys") to
    	// unconditionally include in API requests. By default, fields with
    	// empty values are omitted from API requests. However, any non-pointer,
    	// non-interface field appearing in ForceSendFields will be sent to the
    	// server regardless of whether the field is empty or not. This may be
    	// used to include empty fields in Patch requests.
    	ForceSendFields []string `json:"-"`
    
    	// NullFields is a list of field names (e.g. "Keys") to include in API
    	// requests with the JSON null value. By default, fields with empty
    	// values are omitted from API requests. However, any field with an
    	// empty value appearing in NullFields will be sent to the server as
    	// null. It is an error if a field in this list has a non-empty value.
    	// This may be used to include null fields in Patch requests.
    	NullFields []string `json:"-"`
    }

      AllocateIdsRequest: The request for Datastore.AllocateIds.

      func (*AllocateIdsRequest) MarshalJSON

      func (s *AllocateIdsRequest) MarshalJSON() ([]byte, error)

      type AllocateIdsResponse

      type AllocateIdsResponse struct {
      	// Keys: The keys specified in the request (in the same order), each
      	// with its key path completed with a newly allocated ID.
      	Keys []*Key `json:"keys,omitempty"`
      
      	// ServerResponse contains the HTTP response code and headers from the
      	// server.
      	googleapi.ServerResponse `json:"-"`
      
      	// ForceSendFields is a list of field names (e.g. "Keys") to
      	// unconditionally include in API requests. By default, fields with
      	// empty values are omitted from API requests. However, any non-pointer,
      	// non-interface field appearing in ForceSendFields will be sent to the
      	// server regardless of whether the field is empty or not. This may be
      	// used to include empty fields in Patch requests.
      	ForceSendFields []string `json:"-"`
      
      	// NullFields is a list of field names (e.g. "Keys") to include in API
      	// requests with the JSON null value. By default, fields with empty
      	// values are omitted from API requests. However, any field with an
      	// empty value appearing in NullFields will be sent to the server as
      	// null. It is an error if a field in this list has a non-empty value.
      	// This may be used to include null fields in Patch requests.
      	NullFields []string `json:"-"`
      }

        AllocateIdsResponse: The response for Datastore.AllocateIds.

        func (*AllocateIdsResponse) MarshalJSON

        func (s *AllocateIdsResponse) MarshalJSON() ([]byte, error)

        type ArrayValue

        type ArrayValue struct {
        	// Values: Values in the array. The order of values in an array is
        	// preserved as long as all values have identical settings for
        	// 'exclude_from_indexes'.
        	Values []*Value `json:"values,omitempty"`
        
        	// ForceSendFields is a list of field names (e.g. "Values") to
        	// unconditionally include in API requests. By default, fields with
        	// empty values are omitted from API requests. However, any non-pointer,
        	// non-interface field appearing in ForceSendFields will be sent to the
        	// server regardless of whether the field is empty or not. This may be
        	// used to include empty fields in Patch requests.
        	ForceSendFields []string `json:"-"`
        
        	// NullFields is a list of field names (e.g. "Values") to include in API
        	// requests with the JSON null value. By default, fields with empty
        	// values are omitted from API requests. However, any field with an
        	// empty value appearing in NullFields will be sent to the server as
        	// null. It is an error if a field in this list has a non-empty value.
        	// This may be used to include null fields in Patch requests.
        	NullFields []string `json:"-"`
        }

          ArrayValue: An array value.

          func (*ArrayValue) MarshalJSON

          func (s *ArrayValue) MarshalJSON() ([]byte, error)

          type BeginTransactionRequest

          type BeginTransactionRequest struct {
          	// TransactionOptions: Options for a new transaction.
          	TransactionOptions *TransactionOptions `json:"transactionOptions,omitempty"`
          
          	// ForceSendFields is a list of field names (e.g. "TransactionOptions")
          	// to unconditionally include in API requests. By default, fields with
          	// empty values are omitted from API requests. However, any non-pointer,
          	// non-interface field appearing in ForceSendFields will be sent to the
          	// server regardless of whether the field is empty or not. This may be
          	// used to include empty fields in Patch requests.
          	ForceSendFields []string `json:"-"`
          
          	// NullFields is a list of field names (e.g. "TransactionOptions") to
          	// include in API requests with the JSON null value. By default, fields
          	// with empty values are omitted from API requests. However, any field
          	// with an empty value appearing in NullFields will be sent to the
          	// server as null. It is an error if a field in this list has a
          	// non-empty value. This may be used to include null fields in Patch
          	// requests.
          	NullFields []string `json:"-"`
          }

            BeginTransactionRequest: The request for Datastore.BeginTransaction.

            func (*BeginTransactionRequest) MarshalJSON

            func (s *BeginTransactionRequest) MarshalJSON() ([]byte, error)

            type BeginTransactionResponse

            type BeginTransactionResponse struct {
            	// Transaction: The transaction identifier (always present).
            	Transaction string `json:"transaction,omitempty"`
            
            	// ServerResponse contains the HTTP response code and headers from the
            	// server.
            	googleapi.ServerResponse `json:"-"`
            
            	// ForceSendFields is a list of field names (e.g. "Transaction") to
            	// unconditionally include in API requests. By default, fields with
            	// empty values are omitted from API requests. However, any non-pointer,
            	// non-interface field appearing in ForceSendFields will be sent to the
            	// server regardless of whether the field is empty or not. This may be
            	// used to include empty fields in Patch requests.
            	ForceSendFields []string `json:"-"`
            
            	// NullFields is a list of field names (e.g. "Transaction") to include
            	// in API requests with the JSON null value. By default, fields with
            	// empty values are omitted from API requests. However, any field with
            	// an empty value appearing in NullFields will be sent to the server as
            	// null. It is an error if a field in this list has a non-empty value.
            	// This may be used to include null fields in Patch requests.
            	NullFields []string `json:"-"`
            }

              BeginTransactionResponse: The response for Datastore.BeginTransaction.

              func (*BeginTransactionResponse) MarshalJSON

              func (s *BeginTransactionResponse) MarshalJSON() ([]byte, error)

              type CommitRequest

              type CommitRequest struct {
              	// Mode: The type of commit to perform. Defaults to `TRANSACTIONAL`.
              	//
              	// Possible values:
              	//   "MODE_UNSPECIFIED" - Unspecified. This value must not be used.
              	//   "TRANSACTIONAL" - Transactional: The mutations are either all
              	// applied, or none are applied. Learn about transactions
              	// [here](https://cloud.google.com/datastore/docs/concepts/transactions).
              	//   "NON_TRANSACTIONAL" - Non-transactional: The mutations may not
              	// apply as all or none.
              	Mode string `json:"mode,omitempty"`
              
              	// Mutations: The mutations to perform. When mode is `TRANSACTIONAL`,
              	// mutations affecting a single entity are applied in order. The
              	// following sequences of mutations affecting a single entity are not
              	// permitted in a single `Commit` request: - `insert` followed by
              	// `insert` - `update` followed by `insert` - `upsert` followed by
              	// `insert` - `delete` followed by `update` When mode is
              	// `NON_TRANSACTIONAL`, no two mutations may affect a single entity.
              	Mutations []*Mutation `json:"mutations,omitempty"`
              
              	// Transaction: The identifier of the transaction associated with the
              	// commit. A transaction identifier is returned by a call to
              	// Datastore.BeginTransaction.
              	Transaction string `json:"transaction,omitempty"`
              
              	// ForceSendFields is a list of field names (e.g. "Mode") to
              	// unconditionally include in API requests. By default, fields with
              	// empty values are omitted from API requests. However, any non-pointer,
              	// non-interface field appearing in ForceSendFields will be sent to the
              	// server regardless of whether the field is empty or not. This may be
              	// used to include empty fields in Patch requests.
              	ForceSendFields []string `json:"-"`
              
              	// NullFields is a list of field names (e.g. "Mode") to include in API
              	// requests with the JSON null value. By default, fields with empty
              	// values are omitted from API requests. However, any field with an
              	// empty value appearing in NullFields will be sent to the server as
              	// null. It is an error if a field in this list has a non-empty value.
              	// This may be used to include null fields in Patch requests.
              	NullFields []string `json:"-"`
              }

                CommitRequest: The request for Datastore.Commit.

                func (*CommitRequest) MarshalJSON

                func (s *CommitRequest) MarshalJSON() ([]byte, error)

                type CommitResponse

                type CommitResponse struct {
                	// IndexUpdates: The number of index entries updated during the commit,
                	// or zero if none were updated.
                	IndexUpdates int64 `json:"indexUpdates,omitempty"`
                
                	// MutationResults: The result of performing the mutations. The i-th
                	// mutation result corresponds to the i-th mutation in the request.
                	MutationResults []*MutationResult `json:"mutationResults,omitempty"`
                
                	// ServerResponse contains the HTTP response code and headers from the
                	// server.
                	googleapi.ServerResponse `json:"-"`
                
                	// ForceSendFields is a list of field names (e.g. "IndexUpdates") to
                	// unconditionally include in API requests. By default, fields with
                	// empty values are omitted from API requests. However, any non-pointer,
                	// non-interface field appearing in ForceSendFields will be sent to the
                	// server regardless of whether the field is empty or not. This may be
                	// used to include empty fields in Patch requests.
                	ForceSendFields []string `json:"-"`
                
                	// NullFields is a list of field names (e.g. "IndexUpdates") to include
                	// in API requests with the JSON null value. By default, fields with
                	// empty values are omitted from API requests. However, any field with
                	// an empty value appearing in NullFields will be sent to the server as
                	// null. It is an error if a field in this list has a non-empty value.
                	// This may be used to include null fields in Patch requests.
                	NullFields []string `json:"-"`
                }

                  CommitResponse: The response for Datastore.Commit.

                  func (*CommitResponse) MarshalJSON

                  func (s *CommitResponse) MarshalJSON() ([]byte, error)

                  type CompositeFilter

                  type CompositeFilter struct {
                  	// Filters: The list of filters to combine. Must contain at least one
                  	// filter.
                  	Filters []*Filter `json:"filters,omitempty"`
                  
                  	// Op: The operator for combining multiple filters.
                  	//
                  	// Possible values:
                  	//   "OPERATOR_UNSPECIFIED" - Unspecified. This value must not be used.
                  	//   "AND" - The results are required to satisfy each of the combined
                  	// filters.
                  	Op string `json:"op,omitempty"`
                  
                  	// ForceSendFields is a list of field names (e.g. "Filters") to
                  	// unconditionally include in API requests. By default, fields with
                  	// empty values are omitted from API requests. However, any non-pointer,
                  	// non-interface field appearing in ForceSendFields will be sent to the
                  	// server regardless of whether the field is empty or not. This may be
                  	// used to include empty fields in Patch requests.
                  	ForceSendFields []string `json:"-"`
                  
                  	// NullFields is a list of field names (e.g. "Filters") to include in
                  	// API requests with the JSON null value. By default, fields with empty
                  	// values are omitted from API requests. However, any field with an
                  	// empty value appearing in NullFields will be sent to the server as
                  	// null. It is an error if a field in this list has a non-empty value.
                  	// This may be used to include null fields in Patch requests.
                  	NullFields []string `json:"-"`
                  }

                    CompositeFilter: A filter that merges multiple other filters using the given operator.

                    func (*CompositeFilter) MarshalJSON

                    func (s *CompositeFilter) MarshalJSON() ([]byte, error)

                    type Entity

                    type Entity struct {
                    	// Key: The entity's key. An entity must have a key, unless otherwise
                    	// documented (for example, an entity in `Value.entity_value` may have
                    	// no key). An entity's kind is its key path's last element's kind, or
                    	// null if it has no key.
                    	Key *Key `json:"key,omitempty"`
                    
                    	// Properties: The entity's properties. The map's keys are property
                    	// names. A property name matching regex `__.*__` is reserved. A
                    	// reserved property name is forbidden in certain documented contexts.
                    	// The name must not contain more than 500 characters. The name cannot
                    	// be "".
                    	Properties map[string]Value `json:"properties,omitempty"`
                    
                    	// ForceSendFields is a list of field names (e.g. "Key") to
                    	// unconditionally include in API requests. By default, fields with
                    	// empty values are omitted from API requests. However, any non-pointer,
                    	// non-interface field appearing in ForceSendFields will be sent to the
                    	// server regardless of whether the field is empty or not. This may be
                    	// used to include empty fields in Patch requests.
                    	ForceSendFields []string `json:"-"`
                    
                    	// NullFields is a list of field names (e.g. "Key") to include in API
                    	// requests with the JSON null value. By default, fields with empty
                    	// values are omitted from API requests. However, any field with an
                    	// empty value appearing in NullFields will be sent to the server as
                    	// null. It is an error if a field in this list has a non-empty value.
                    	// This may be used to include null fields in Patch requests.
                    	NullFields []string `json:"-"`
                    }

                      Entity: A Datastore data object. An entity is limited to 1 megabyte when stored. That _roughly_ corresponds to a limit of 1 megabyte for the serialized form of this message.

                      func (*Entity) MarshalJSON

                      func (s *Entity) MarshalJSON() ([]byte, error)

                      type EntityResult

                      type EntityResult struct {
                      	// Cursor: A cursor that points to the position after the result entity.
                      	// Set only when the `EntityResult` is part of a `QueryResultBatch`
                      	// message.
                      	Cursor string `json:"cursor,omitempty"`
                      
                      	// Entity: The resulting entity.
                      	Entity *Entity `json:"entity,omitempty"`
                      
                      	// Version: The version of the entity, a strictly positive number that
                      	// monotonically increases with changes to the entity. This field is set
                      	// for `FULL` entity results. For missing entities in `LookupResponse`,
                      	// this is the version of the snapshot that was used to look up the
                      	// entity, and it is always set except for eventually consistent reads.
                      	Version int64 `json:"version,omitempty,string"`
                      
                      	// ForceSendFields is a list of field names (e.g. "Cursor") to
                      	// unconditionally include in API requests. By default, fields with
                      	// empty values are omitted from API requests. However, any non-pointer,
                      	// non-interface field appearing in ForceSendFields will be sent to the
                      	// server regardless of whether the field is empty or not. This may be
                      	// used to include empty fields in Patch requests.
                      	ForceSendFields []string `json:"-"`
                      
                      	// NullFields is a list of field names (e.g. "Cursor") to include in API
                      	// requests with the JSON null value. By default, fields with empty
                      	// values are omitted from API requests. However, any field with an
                      	// empty value appearing in NullFields will be sent to the server as
                      	// null. It is an error if a field in this list has a non-empty value.
                      	// This may be used to include null fields in Patch requests.
                      	NullFields []string `json:"-"`
                      }

                        EntityResult: The result of fetching an entity from Datastore.

                        func (*EntityResult) MarshalJSON

                        func (s *EntityResult) MarshalJSON() ([]byte, error)

                        type Filter

                        type Filter struct {
                        	// CompositeFilter: A composite filter.
                        	CompositeFilter *CompositeFilter `json:"compositeFilter,omitempty"`
                        
                        	// PropertyFilter: A filter on a property.
                        	PropertyFilter *PropertyFilter `json:"propertyFilter,omitempty"`
                        
                        	// ForceSendFields is a list of field names (e.g. "CompositeFilter") to
                        	// unconditionally include in API requests. By default, fields with
                        	// empty values are omitted from API requests. However, any non-pointer,
                        	// non-interface field appearing in ForceSendFields will be sent to the
                        	// server regardless of whether the field is empty or not. This may be
                        	// used to include empty fields in Patch requests.
                        	ForceSendFields []string `json:"-"`
                        
                        	// NullFields is a list of field names (e.g. "CompositeFilter") to
                        	// include in API requests with the JSON null value. By default, fields
                        	// with empty values are omitted from API requests. However, any field
                        	// with an empty value appearing in NullFields will be sent to the
                        	// server as null. It is an error if a field in this list has a
                        	// non-empty value. This may be used to include null fields in Patch
                        	// requests.
                        	NullFields []string `json:"-"`
                        }

                          Filter: A holder for any type of filter.

                          func (*Filter) MarshalJSON

                          func (s *Filter) MarshalJSON() ([]byte, error)

                          type GoogleDatastoreAdminV1CommonMetadata

                          type GoogleDatastoreAdminV1CommonMetadata struct {
                          	// EndTime: The time the operation ended, either successfully or
                          	// otherwise.
                          	EndTime string `json:"endTime,omitempty"`
                          
                          	// Labels: The client-assigned labels which were provided when the
                          	// operation was created. May also include additional labels.
                          	Labels map[string]string `json:"labels,omitempty"`
                          
                          	// OperationType: The type of the operation. Can be used as a filter in
                          	// ListOperationsRequest.
                          	//
                          	// Possible values:
                          	//   "OPERATION_TYPE_UNSPECIFIED" - Unspecified.
                          	//   "EXPORT_ENTITIES" - ExportEntities.
                          	//   "IMPORT_ENTITIES" - ImportEntities.
                          	//   "CREATE_INDEX" - CreateIndex.
                          	//   "DELETE_INDEX" - DeleteIndex.
                          	OperationType string `json:"operationType,omitempty"`
                          
                          	// StartTime: The time that work began on the operation.
                          	StartTime string `json:"startTime,omitempty"`
                          
                          	// State: The current state of the Operation.
                          	//
                          	// Possible values:
                          	//   "STATE_UNSPECIFIED" - Unspecified.
                          	//   "INITIALIZING" - Request is being prepared for processing.
                          	//   "PROCESSING" - Request is actively being processed.
                          	//   "CANCELLING" - Request is in the process of being cancelled after
                          	// user called google.longrunning.Operations.CancelOperation on the
                          	// operation.
                          	//   "FINALIZING" - Request has been processed and is in its
                          	// finalization stage.
                          	//   "SUCCESSFUL" - Request has completed successfully.
                          	//   "FAILED" - Request has finished being processed, but encountered an
                          	// error.
                          	//   "CANCELLED" - Request has finished being cancelled after user
                          	// called google.longrunning.Operations.CancelOperation.
                          	State string `json:"state,omitempty"`
                          
                          	// ForceSendFields is a list of field names (e.g. "EndTime") to
                          	// unconditionally include in API requests. By default, fields with
                          	// empty values are omitted from API requests. However, any non-pointer,
                          	// non-interface field appearing in ForceSendFields will be sent to the
                          	// server regardless of whether the field is empty or not. This may be
                          	// used to include empty fields in Patch requests.
                          	ForceSendFields []string `json:"-"`
                          
                          	// NullFields is a list of field names (e.g. "EndTime") to include in
                          	// API requests with the JSON null value. By default, fields with empty
                          	// values are omitted from API requests. However, any field with an
                          	// empty value appearing in NullFields will be sent to the server as
                          	// null. It is an error if a field in this list has a non-empty value.
                          	// This may be used to include null fields in Patch requests.
                          	NullFields []string `json:"-"`
                          }

                            GoogleDatastoreAdminV1CommonMetadata: Metadata common to all Datastore Admin operations.

                            func (*GoogleDatastoreAdminV1CommonMetadata) MarshalJSON

                            func (s *GoogleDatastoreAdminV1CommonMetadata) MarshalJSON() ([]byte, error)

                            type GoogleDatastoreAdminV1EntityFilter

                            type GoogleDatastoreAdminV1EntityFilter struct {
                            	// Kinds: If empty, then this represents all kinds.
                            	Kinds []string `json:"kinds,omitempty"`
                            
                            	// NamespaceIds: An empty list represents all namespaces. This is the
                            	// preferred usage for projects that don't use namespaces. An empty
                            	// string element represents the default namespace. This should be used
                            	// if the project has data in non-default namespaces, but doesn't want
                            	// to include them. Each namespace in this list must be unique.
                            	NamespaceIds []string `json:"namespaceIds,omitempty"`
                            
                            	// ForceSendFields is a list of field names (e.g. "Kinds") to
                            	// unconditionally include in API requests. By default, fields with
                            	// empty values are omitted from API requests. However, any non-pointer,
                            	// non-interface field appearing in ForceSendFields will be sent to the
                            	// server regardless of whether the field is empty or not. This may be
                            	// used to include empty fields in Patch requests.
                            	ForceSendFields []string `json:"-"`
                            
                            	// NullFields is a list of field names (e.g. "Kinds") to include in API
                            	// requests with the JSON null value. By default, fields with empty
                            	// values are omitted from API requests. However, any field with an
                            	// empty value appearing in NullFields will be sent to the server as
                            	// null. It is an error if a field in this list has a non-empty value.
                            	// This may be used to include null fields in Patch requests.
                            	NullFields []string `json:"-"`
                            }

                              GoogleDatastoreAdminV1EntityFilter: Identifies a subset of entities in a project. This is specified as combinations of kinds and namespaces (either or both of which may be all, as described in the following examples). Example usage: Entire project: kinds=[], namespace_ids=[] Kinds Foo and Bar in all namespaces: kinds=['Foo', 'Bar'], namespace_ids=[] Kinds Foo and Bar only in the default namespace: kinds=['Foo', 'Bar'], namespace_ids=[”] Kinds Foo and Bar in both the default and Baz namespaces: kinds=['Foo', 'Bar'], namespace_ids=[”, 'Baz'] The entire Baz namespace: kinds=[], namespace_ids=['Baz']

                              func (*GoogleDatastoreAdminV1EntityFilter) MarshalJSON

                              func (s *GoogleDatastoreAdminV1EntityFilter) MarshalJSON() ([]byte, error)

                              type GoogleDatastoreAdminV1ExportEntitiesMetadata

                              type GoogleDatastoreAdminV1ExportEntitiesMetadata struct {
                              	// Common: Metadata common to all Datastore Admin operations.
                              	Common *GoogleDatastoreAdminV1CommonMetadata `json:"common,omitempty"`
                              
                              	// EntityFilter: Description of which entities are being exported.
                              	EntityFilter *GoogleDatastoreAdminV1EntityFilter `json:"entityFilter,omitempty"`
                              
                              	// OutputUrlPrefix: Location for the export metadata and data files.
                              	// This will be the same value as the
                              	// google.datastore.admin.v1.ExportEntitiesRequest.output_url_prefix
                              	// field. The final output location is provided in
                              	// google.datastore.admin.v1.ExportEntitiesResponse.output_url.
                              	OutputUrlPrefix string `json:"outputUrlPrefix,omitempty"`
                              
                              	// ProgressBytes: An estimate of the number of bytes processed.
                              	ProgressBytes *GoogleDatastoreAdminV1Progress `json:"progressBytes,omitempty"`
                              
                              	// ProgressEntities: An estimate of the number of entities processed.
                              	ProgressEntities *GoogleDatastoreAdminV1Progress `json:"progressEntities,omitempty"`
                              
                              	// ForceSendFields is a list of field names (e.g. "Common") to
                              	// unconditionally include in API requests. By default, fields with
                              	// empty values are omitted from API requests. However, any non-pointer,
                              	// non-interface field appearing in ForceSendFields will be sent to the
                              	// server regardless of whether the field is empty or not. This may be
                              	// used to include empty fields in Patch requests.
                              	ForceSendFields []string `json:"-"`
                              
                              	// NullFields is a list of field names (e.g. "Common") to include in API
                              	// requests with the JSON null value. By default, fields with empty
                              	// values are omitted from API requests. However, any field with an
                              	// empty value appearing in NullFields will be sent to the server as
                              	// null. It is an error if a field in this list has a non-empty value.
                              	// This may be used to include null fields in Patch requests.
                              	NullFields []string `json:"-"`
                              }

                                GoogleDatastoreAdminV1ExportEntitiesMetadata: Metadata for ExportEntities operations.

                                func (*GoogleDatastoreAdminV1ExportEntitiesMetadata) MarshalJSON

                                type GoogleDatastoreAdminV1ExportEntitiesResponse

                                type GoogleDatastoreAdminV1ExportEntitiesResponse struct {
                                	// OutputUrl: Location of the output metadata file. This can be used to
                                	// begin an import into Cloud Datastore (this project or another
                                	// project). See
                                	// google.datastore.admin.v1.ImportEntitiesRequest.input_url. Only
                                	// present if the operation completed successfully.
                                	OutputUrl string `json:"outputUrl,omitempty"`
                                
                                	// ForceSendFields is a list of field names (e.g. "OutputUrl") to
                                	// unconditionally include in API requests. By default, fields with
                                	// empty values are omitted from API requests. However, any non-pointer,
                                	// non-interface field appearing in ForceSendFields will be sent to the
                                	// server regardless of whether the field is empty or not. This may be
                                	// used to include empty fields in Patch requests.
                                	ForceSendFields []string `json:"-"`
                                
                                	// NullFields is a list of field names (e.g. "OutputUrl") to include in
                                	// API requests with the JSON null value. By default, fields with empty
                                	// values are omitted from API requests. However, any field with an
                                	// empty value appearing in NullFields will be sent to the server as
                                	// null. It is an error if a field in this list has a non-empty value.
                                	// This may be used to include null fields in Patch requests.
                                	NullFields []string `json:"-"`
                                }

                                  GoogleDatastoreAdminV1ExportEntitiesResponse: The response for google.datastore.admin.v1.DatastoreAdmin.ExportEntities.

                                  func (*GoogleDatastoreAdminV1ExportEntitiesResponse) MarshalJSON

                                  type GoogleDatastoreAdminV1ImportEntitiesMetadata

                                  type GoogleDatastoreAdminV1ImportEntitiesMetadata struct {
                                  	// Common: Metadata common to all Datastore Admin operations.
                                  	Common *GoogleDatastoreAdminV1CommonMetadata `json:"common,omitempty"`
                                  
                                  	// EntityFilter: Description of which entities are being imported.
                                  	EntityFilter *GoogleDatastoreAdminV1EntityFilter `json:"entityFilter,omitempty"`
                                  
                                  	// InputUrl: The location of the import metadata file. This will be the
                                  	// same value as the
                                  	// google.datastore.admin.v1.ExportEntitiesResponse.output_url field.
                                  	InputUrl string `json:"inputUrl,omitempty"`
                                  
                                  	// ProgressBytes: An estimate of the number of bytes processed.
                                  	ProgressBytes *GoogleDatastoreAdminV1Progress `json:"progressBytes,omitempty"`
                                  
                                  	// ProgressEntities: An estimate of the number of entities processed.
                                  	ProgressEntities *GoogleDatastoreAdminV1Progress `json:"progressEntities,omitempty"`
                                  
                                  	// ForceSendFields is a list of field names (e.g. "Common") to
                                  	// unconditionally include in API requests. By default, fields with
                                  	// empty values are omitted from API requests. However, any non-pointer,
                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                  	// server regardless of whether the field is empty or not. This may be
                                  	// used to include empty fields in Patch requests.
                                  	ForceSendFields []string `json:"-"`
                                  
                                  	// NullFields is a list of field names (e.g. "Common") to include in API
                                  	// requests with the JSON null value. By default, fields with empty
                                  	// values are omitted from API requests. However, any field with an
                                  	// empty value appearing in NullFields will be sent to the server as
                                  	// null. It is an error if a field in this list has a non-empty value.
                                  	// This may be used to include null fields in Patch requests.
                                  	NullFields []string `json:"-"`
                                  }

                                    GoogleDatastoreAdminV1ImportEntitiesMetadata: Metadata for ImportEntities operations.

                                    func (*GoogleDatastoreAdminV1ImportEntitiesMetadata) MarshalJSON

                                    type GoogleDatastoreAdminV1IndexOperationMetadata

                                    type GoogleDatastoreAdminV1IndexOperationMetadata struct {
                                    	// Common: Metadata common to all Datastore Admin operations.
                                    	Common *GoogleDatastoreAdminV1CommonMetadata `json:"common,omitempty"`
                                    
                                    	// IndexId: The index resource ID that this operation is acting on.
                                    	IndexId string `json:"indexId,omitempty"`
                                    
                                    	// ProgressEntities: An estimate of the number of entities processed.
                                    	ProgressEntities *GoogleDatastoreAdminV1Progress `json:"progressEntities,omitempty"`
                                    
                                    	// ForceSendFields is a list of field names (e.g. "Common") to
                                    	// unconditionally include in API requests. By default, fields with
                                    	// empty values are omitted from API requests. However, any non-pointer,
                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                    	// server regardless of whether the field is empty or not. This may be
                                    	// used to include empty fields in Patch requests.
                                    	ForceSendFields []string `json:"-"`
                                    
                                    	// NullFields is a list of field names (e.g. "Common") to include in API
                                    	// requests with the JSON null value. By default, fields with empty
                                    	// values are omitted from API requests. However, any field with an
                                    	// empty value appearing in NullFields will be sent to the server as
                                    	// null. It is an error if a field in this list has a non-empty value.
                                    	// This may be used to include null fields in Patch requests.
                                    	NullFields []string `json:"-"`
                                    }

                                      GoogleDatastoreAdminV1IndexOperationMetadata: Metadata for Index operations.

                                      func (*GoogleDatastoreAdminV1IndexOperationMetadata) MarshalJSON

                                      type GoogleDatastoreAdminV1Progress

                                      type GoogleDatastoreAdminV1Progress struct {
                                      	// WorkCompleted: The amount of work that has been completed. Note that
                                      	// this may be greater than work_estimated.
                                      	WorkCompleted int64 `json:"workCompleted,omitempty,string"`
                                      
                                      	// WorkEstimated: An estimate of how much work needs to be performed.
                                      	// May be zero if the work estimate is unavailable.
                                      	WorkEstimated int64 `json:"workEstimated,omitempty,string"`
                                      
                                      	// ForceSendFields is a list of field names (e.g. "WorkCompleted") to
                                      	// unconditionally include in API requests. By default, fields with
                                      	// empty values are omitted from API requests. However, any non-pointer,
                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                      	// server regardless of whether the field is empty or not. This may be
                                      	// used to include empty fields in Patch requests.
                                      	ForceSendFields []string `json:"-"`
                                      
                                      	// NullFields is a list of field names (e.g. "WorkCompleted") to include
                                      	// in API requests with the JSON null value. By default, fields with
                                      	// empty values are omitted from API requests. However, any field with
                                      	// an empty value appearing in NullFields will be sent to the server as
                                      	// null. It is an error if a field in this list has a non-empty value.
                                      	// This may be used to include null fields in Patch requests.
                                      	NullFields []string `json:"-"`
                                      }

                                        GoogleDatastoreAdminV1Progress: Measures the progress of a particular metric.

                                        func (*GoogleDatastoreAdminV1Progress) MarshalJSON

                                        func (s *GoogleDatastoreAdminV1Progress) MarshalJSON() ([]byte, error)

                                        type GoogleDatastoreAdminV1beta1CommonMetadata

                                        type GoogleDatastoreAdminV1beta1CommonMetadata struct {
                                        	// EndTime: The time the operation ended, either successfully or
                                        	// otherwise.
                                        	EndTime string `json:"endTime,omitempty"`
                                        
                                        	// Labels: The client-assigned labels which were provided when the
                                        	// operation was created. May also include additional labels.
                                        	Labels map[string]string `json:"labels,omitempty"`
                                        
                                        	// OperationType: The type of the operation. Can be used as a filter in
                                        	// ListOperationsRequest.
                                        	//
                                        	// Possible values:
                                        	//   "OPERATION_TYPE_UNSPECIFIED" - Unspecified.
                                        	//   "EXPORT_ENTITIES" - ExportEntities.
                                        	//   "IMPORT_ENTITIES" - ImportEntities.
                                        	OperationType string `json:"operationType,omitempty"`
                                        
                                        	// StartTime: The time that work began on the operation.
                                        	StartTime string `json:"startTime,omitempty"`
                                        
                                        	// State: The current state of the Operation.
                                        	//
                                        	// Possible values:
                                        	//   "STATE_UNSPECIFIED" - Unspecified.
                                        	//   "INITIALIZING" - Request is being prepared for processing.
                                        	//   "PROCESSING" - Request is actively being processed.
                                        	//   "CANCELLING" - Request is in the process of being cancelled after
                                        	// user called google.longrunning.Operations.CancelOperation on the
                                        	// operation.
                                        	//   "FINALIZING" - Request has been processed and is in its
                                        	// finalization stage.
                                        	//   "SUCCESSFUL" - Request has completed successfully.
                                        	//   "FAILED" - Request has finished being processed, but encountered an
                                        	// error.
                                        	//   "CANCELLED" - Request has finished being cancelled after user
                                        	// called google.longrunning.Operations.CancelOperation.
                                        	State string `json:"state,omitempty"`
                                        
                                        	// ForceSendFields is a list of field names (e.g. "EndTime") to
                                        	// unconditionally include in API requests. By default, fields with
                                        	// empty values are omitted from API requests. However, any non-pointer,
                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                        	// server regardless of whether the field is empty or not. This may be
                                        	// used to include empty fields in Patch requests.
                                        	ForceSendFields []string `json:"-"`
                                        
                                        	// NullFields is a list of field names (e.g. "EndTime") to include in
                                        	// API requests with the JSON null value. By default, fields with empty
                                        	// values are omitted from API requests. However, any field with an
                                        	// empty value appearing in NullFields will be sent to the server as
                                        	// null. It is an error if a field in this list has a non-empty value.
                                        	// This may be used to include null fields in Patch requests.
                                        	NullFields []string `json:"-"`
                                        }

                                          GoogleDatastoreAdminV1beta1CommonMetadata: Metadata common to all Datastore Admin operations.

                                          func (*GoogleDatastoreAdminV1beta1CommonMetadata) MarshalJSON

                                          type GoogleDatastoreAdminV1beta1EntityFilter

                                          type GoogleDatastoreAdminV1beta1EntityFilter struct {
                                          	// Kinds: If empty, then this represents all kinds.
                                          	Kinds []string `json:"kinds,omitempty"`
                                          
                                          	// NamespaceIds: An empty list represents all namespaces. This is the
                                          	// preferred usage for projects that don't use namespaces. An empty
                                          	// string element represents the default namespace. This should be used
                                          	// if the project has data in non-default namespaces, but doesn't want
                                          	// to include them. Each namespace in this list must be unique.
                                          	NamespaceIds []string `json:"namespaceIds,omitempty"`
                                          
                                          	// ForceSendFields is a list of field names (e.g. "Kinds") to
                                          	// unconditionally include in API requests. By default, fields with
                                          	// empty values are omitted from API requests. However, any non-pointer,
                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                          	// server regardless of whether the field is empty or not. This may be
                                          	// used to include empty fields in Patch requests.
                                          	ForceSendFields []string `json:"-"`
                                          
                                          	// NullFields is a list of field names (e.g. "Kinds") to include in API
                                          	// requests with the JSON null value. By default, fields with empty
                                          	// values are omitted from API requests. However, any field with an
                                          	// empty value appearing in NullFields will be sent to the server as
                                          	// null. It is an error if a field in this list has a non-empty value.
                                          	// This may be used to include null fields in Patch requests.
                                          	NullFields []string `json:"-"`
                                          }

                                            GoogleDatastoreAdminV1beta1EntityFilter: Identifies a subset of entities in a project. This is specified as combinations of kinds and namespaces (either or both of which may be all, as described in the following examples). Example usage: Entire project: kinds=[], namespace_ids=[] Kinds Foo and Bar in all namespaces: kinds=['Foo', 'Bar'], namespace_ids=[] Kinds Foo and Bar only in the default namespace: kinds=['Foo', 'Bar'], namespace_ids=[”] Kinds Foo and Bar in both the default and Baz namespaces: kinds=['Foo', 'Bar'], namespace_ids=[”, 'Baz'] The entire Baz namespace: kinds=[], namespace_ids=['Baz']

                                            func (*GoogleDatastoreAdminV1beta1EntityFilter) MarshalJSON

                                            func (s *GoogleDatastoreAdminV1beta1EntityFilter) MarshalJSON() ([]byte, error)

                                            type GoogleDatastoreAdminV1beta1ExportEntitiesMetadata

                                            type GoogleDatastoreAdminV1beta1ExportEntitiesMetadata struct {
                                            	// Common: Metadata common to all Datastore Admin operations.
                                            	Common *GoogleDatastoreAdminV1beta1CommonMetadata `json:"common,omitempty"`
                                            
                                            	// EntityFilter: Description of which entities are being exported.
                                            	EntityFilter *GoogleDatastoreAdminV1beta1EntityFilter `json:"entityFilter,omitempty"`
                                            
                                            	// OutputUrlPrefix: Location for the export metadata and data files.
                                            	// This will be the same value as the
                                            	// google.datastore.admin.v1beta1.ExportEntitiesRequest.output_url_prefix
                                            	//  field. The final output location is provided in
                                            	// google.datastore.admin.v1beta1.ExportEntitiesResponse.output_url.
                                            	OutputUrlPrefix string `json:"outputUrlPrefix,omitempty"`
                                            
                                            	// ProgressBytes: An estimate of the number of bytes processed.
                                            	ProgressBytes *GoogleDatastoreAdminV1beta1Progress `json:"progressBytes,omitempty"`
                                            
                                            	// ProgressEntities: An estimate of the number of entities processed.
                                            	ProgressEntities *GoogleDatastoreAdminV1beta1Progress `json:"progressEntities,omitempty"`
                                            
                                            	// ForceSendFields is a list of field names (e.g. "Common") to
                                            	// unconditionally include in API requests. By default, fields with
                                            	// empty values are omitted from API requests. However, any non-pointer,
                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                            	// server regardless of whether the field is empty or not. This may be
                                            	// used to include empty fields in Patch requests.
                                            	ForceSendFields []string `json:"-"`
                                            
                                            	// NullFields is a list of field names (e.g. "Common") to include in API
                                            	// requests with the JSON null value. By default, fields with empty
                                            	// values are omitted from API requests. However, any field with an
                                            	// empty value appearing in NullFields will be sent to the server as
                                            	// null. It is an error if a field in this list has a non-empty value.
                                            	// This may be used to include null fields in Patch requests.
                                            	NullFields []string `json:"-"`
                                            }

                                              GoogleDatastoreAdminV1beta1ExportEntitiesMetadata: Metadata for ExportEntities operations.

                                              func (*GoogleDatastoreAdminV1beta1ExportEntitiesMetadata) MarshalJSON

                                              type GoogleDatastoreAdminV1beta1ExportEntitiesResponse

                                              type GoogleDatastoreAdminV1beta1ExportEntitiesResponse struct {
                                              	// OutputUrl: Location of the output metadata file. This can be used to
                                              	// begin an import into Cloud Datastore (this project or another
                                              	// project). See
                                              	// google.datastore.admin.v1beta1.ImportEntitiesRequest.input_url. Only
                                              	// present if the operation completed successfully.
                                              	OutputUrl string `json:"outputUrl,omitempty"`
                                              
                                              	// ForceSendFields is a list of field names (e.g. "OutputUrl") to
                                              	// unconditionally include in API requests. By default, fields with
                                              	// empty values are omitted from API requests. However, any non-pointer,
                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                              	// server regardless of whether the field is empty or not. This may be
                                              	// used to include empty fields in Patch requests.
                                              	ForceSendFields []string `json:"-"`
                                              
                                              	// NullFields is a list of field names (e.g. "OutputUrl") to include in
                                              	// API requests with the JSON null value. By default, fields with empty
                                              	// values are omitted from API requests. However, any field with an
                                              	// empty value appearing in NullFields will be sent to the server as
                                              	// null. It is an error if a field in this list has a non-empty value.
                                              	// This may be used to include null fields in Patch requests.
                                              	NullFields []string `json:"-"`
                                              }

                                                GoogleDatastoreAdminV1beta1ExportEntitiesResponse: The response for google.datastore.admin.v1beta1.DatastoreAdmin.ExportEntities.

                                                func (*GoogleDatastoreAdminV1beta1ExportEntitiesResponse) MarshalJSON

                                                type GoogleDatastoreAdminV1beta1ImportEntitiesMetadata

                                                type GoogleDatastoreAdminV1beta1ImportEntitiesMetadata struct {
                                                	// Common: Metadata common to all Datastore Admin operations.
                                                	Common *GoogleDatastoreAdminV1beta1CommonMetadata `json:"common,omitempty"`
                                                
                                                	// EntityFilter: Description of which entities are being imported.
                                                	EntityFilter *GoogleDatastoreAdminV1beta1EntityFilter `json:"entityFilter,omitempty"`
                                                
                                                	// InputUrl: The location of the import metadata file. This will be the
                                                	// same value as the
                                                	// google.datastore.admin.v1beta1.ExportEntitiesResponse.output_url
                                                	// field.
                                                	InputUrl string `json:"inputUrl,omitempty"`
                                                
                                                	// ProgressBytes: An estimate of the number of bytes processed.
                                                	ProgressBytes *GoogleDatastoreAdminV1beta1Progress `json:"progressBytes,omitempty"`
                                                
                                                	// ProgressEntities: An estimate of the number of entities processed.
                                                	ProgressEntities *GoogleDatastoreAdminV1beta1Progress `json:"progressEntities,omitempty"`
                                                
                                                	// ForceSendFields is a list of field names (e.g. "Common") to
                                                	// unconditionally include in API requests. By default, fields with
                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                	// server regardless of whether the field is empty or not. This may be
                                                	// used to include empty fields in Patch requests.
                                                	ForceSendFields []string `json:"-"`
                                                
                                                	// NullFields is a list of field names (e.g. "Common") to include in API
                                                	// requests with the JSON null value. By default, fields with empty
                                                	// values are omitted from API requests. However, any field with an
                                                	// empty value appearing in NullFields will be sent to the server as
                                                	// null. It is an error if a field in this list has a non-empty value.
                                                	// This may be used to include null fields in Patch requests.
                                                	NullFields []string `json:"-"`
                                                }

                                                  GoogleDatastoreAdminV1beta1ImportEntitiesMetadata: Metadata for ImportEntities operations.

                                                  func (*GoogleDatastoreAdminV1beta1ImportEntitiesMetadata) MarshalJSON

                                                  type GoogleDatastoreAdminV1beta1Progress

                                                  type GoogleDatastoreAdminV1beta1Progress struct {
                                                  	// WorkCompleted: The amount of work that has been completed. Note that
                                                  	// this may be greater than work_estimated.
                                                  	WorkCompleted int64 `json:"workCompleted,omitempty,string"`
                                                  
                                                  	// WorkEstimated: An estimate of how much work needs to be performed.
                                                  	// May be zero if the work estimate is unavailable.
                                                  	WorkEstimated int64 `json:"workEstimated,omitempty,string"`
                                                  
                                                  	// ForceSendFields is a list of field names (e.g. "WorkCompleted") to
                                                  	// unconditionally include in API requests. By default, fields with
                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                  	// server regardless of whether the field is empty or not. This may be
                                                  	// used to include empty fields in Patch requests.
                                                  	ForceSendFields []string `json:"-"`
                                                  
                                                  	// NullFields is a list of field names (e.g. "WorkCompleted") to include
                                                  	// in API requests with the JSON null value. By default, fields with
                                                  	// empty values are omitted from API requests. However, any field with
                                                  	// an empty value appearing in NullFields will be sent to the server as
                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                  	// This may be used to include null fields in Patch requests.
                                                  	NullFields []string `json:"-"`
                                                  }

                                                    GoogleDatastoreAdminV1beta1Progress: Measures the progress of a particular metric.

                                                    func (*GoogleDatastoreAdminV1beta1Progress) MarshalJSON

                                                    func (s *GoogleDatastoreAdminV1beta1Progress) MarshalJSON() ([]byte, error)

                                                    type GqlQuery

                                                    type GqlQuery struct {
                                                    	// AllowLiterals: When false, the query string must not contain any
                                                    	// literals and instead must bind all values. For example, `SELECT *
                                                    	// FROM Kind WHERE a = 'string literal'` is not allowed, while `SELECT *
                                                    	// FROM Kind WHERE a = @value` is.
                                                    	AllowLiterals bool `json:"allowLiterals,omitempty"`
                                                    
                                                    	// NamedBindings: For each non-reserved named binding site in the query
                                                    	// string, there must be a named parameter with that name, but not
                                                    	// necessarily the inverse. Key must match regex `A-Za-z_$*`, must not
                                                    	// match regex `__.*__`, and must not be "".
                                                    	NamedBindings map[string]GqlQueryParameter `json:"namedBindings,omitempty"`
                                                    
                                                    	// PositionalBindings: Numbered binding site @1 references the first
                                                    	// numbered parameter, effectively using 1-based indexing, rather than
                                                    	// the usual 0. For each binding site numbered i in `query_string`,
                                                    	// there must be an i-th numbered parameter. The inverse must also be
                                                    	// true.
                                                    	PositionalBindings []*GqlQueryParameter `json:"positionalBindings,omitempty"`
                                                    
                                                    	// QueryString: A string of the format described here
                                                    	// (https://cloud.google.com/datastore/docs/apis/gql/gql_reference).
                                                    	QueryString string `json:"queryString,omitempty"`
                                                    
                                                    	// ForceSendFields is a list of field names (e.g. "AllowLiterals") to
                                                    	// unconditionally include in API requests. By default, fields with
                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                    	// server regardless of whether the field is empty or not. This may be
                                                    	// used to include empty fields in Patch requests.
                                                    	ForceSendFields []string `json:"-"`
                                                    
                                                    	// NullFields is a list of field names (e.g. "AllowLiterals") to include
                                                    	// in API requests with the JSON null value. By default, fields with
                                                    	// empty values are omitted from API requests. However, any field with
                                                    	// an empty value appearing in NullFields will be sent to the server as
                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                    	// This may be used to include null fields in Patch requests.
                                                    	NullFields []string `json:"-"`
                                                    }

                                                      GqlQuery: A GQL query (https://cloud.google.com/datastore/docs/apis/gql/gql_reference).

                                                      func (*GqlQuery) MarshalJSON

                                                      func (s *GqlQuery) MarshalJSON() ([]byte, error)

                                                      type GqlQueryParameter

                                                      type GqlQueryParameter struct {
                                                      	// Cursor: A query cursor. Query cursors are returned in query result
                                                      	// batches.
                                                      	Cursor string `json:"cursor,omitempty"`
                                                      
                                                      	// Value: A value parameter.
                                                      	Value *Value `json:"value,omitempty"`
                                                      
                                                      	// ForceSendFields is a list of field names (e.g. "Cursor") to
                                                      	// unconditionally include in API requests. By default, fields with
                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                      	// server regardless of whether the field is empty or not. This may be
                                                      	// used to include empty fields in Patch requests.
                                                      	ForceSendFields []string `json:"-"`
                                                      
                                                      	// NullFields is a list of field names (e.g. "Cursor") to include in API
                                                      	// requests with the JSON null value. By default, fields with empty
                                                      	// values are omitted from API requests. However, any field with an
                                                      	// empty value appearing in NullFields will be sent to the server as
                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                      	// This may be used to include null fields in Patch requests.
                                                      	NullFields []string `json:"-"`
                                                      }

                                                        GqlQueryParameter: A binding parameter for a GQL query.

                                                        func (*GqlQueryParameter) MarshalJSON

                                                        func (s *GqlQueryParameter) MarshalJSON() ([]byte, error)

                                                        type Key

                                                        type Key struct {
                                                        	// PartitionId: Entities are partitioned into subsets, currently
                                                        	// identified by a project ID and namespace ID. Queries are scoped to a
                                                        	// single partition.
                                                        	PartitionId *PartitionId `json:"partitionId,omitempty"`
                                                        
                                                        	// Path: The entity path. An entity path consists of one or more
                                                        	// elements composed of a kind and a string or numerical identifier,
                                                        	// which identify entities. The first element identifies a _root
                                                        	// entity_, the second element identifies a _child_ of the root entity,
                                                        	// the third element identifies a child of the second entity, and so
                                                        	// forth. The entities identified by all prefixes of the path are called
                                                        	// the element's _ancestors_. An entity path is always fully complete:
                                                        	// *all* of the entity's ancestors are required to be in the path along
                                                        	// with the entity identifier itself. The only exception is that in some
                                                        	// documented cases, the identifier in the last path element (for the
                                                        	// entity) itself may be omitted. For example, the last path element of
                                                        	// the key of `Mutation.insert` may have no identifier. A path can never
                                                        	// be empty, and a path can have at most 100 elements.
                                                        	Path []*PathElement `json:"path,omitempty"`
                                                        
                                                        	// ForceSendFields is a list of field names (e.g. "PartitionId") to
                                                        	// unconditionally include in API requests. By default, fields with
                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                        	// server regardless of whether the field is empty or not. This may be
                                                        	// used to include empty fields in Patch requests.
                                                        	ForceSendFields []string `json:"-"`
                                                        
                                                        	// NullFields is a list of field names (e.g. "PartitionId") to include
                                                        	// in API requests with the JSON null value. By default, fields with
                                                        	// empty values are omitted from API requests. However, any field with
                                                        	// an empty value appearing in NullFields will be sent to the server as
                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                        	// This may be used to include null fields in Patch requests.
                                                        	NullFields []string `json:"-"`
                                                        }

                                                          Key: A unique identifier for an entity. If a key's partition ID or any of its path kinds or names are reserved/read-only, the key is reserved/read-only. A reserved/read-only key is forbidden in certain documented contexts.

                                                          func (*Key) MarshalJSON

                                                          func (s *Key) MarshalJSON() ([]byte, error)

                                                          type KindExpression

                                                          type KindExpression struct {
                                                          	// Name: The name of the kind.
                                                          	Name string `json:"name,omitempty"`
                                                          
                                                          	// ForceSendFields is a list of field names (e.g. "Name") to
                                                          	// unconditionally include in API requests. By default, fields with
                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                          	// server regardless of whether the field is empty or not. This may be
                                                          	// used to include empty fields in Patch requests.
                                                          	ForceSendFields []string `json:"-"`
                                                          
                                                          	// NullFields is a list of field names (e.g. "Name") to include in API
                                                          	// requests with the JSON null value. By default, fields with empty
                                                          	// values are omitted from API requests. However, any field with an
                                                          	// empty value appearing in NullFields will be sent to the server as
                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                          	// This may be used to include null fields in Patch requests.
                                                          	NullFields []string `json:"-"`
                                                          }

                                                            KindExpression: A representation of a kind.

                                                            func (*KindExpression) MarshalJSON

                                                            func (s *KindExpression) MarshalJSON() ([]byte, error)

                                                            type LatLng

                                                            type LatLng struct {
                                                            	// Latitude: The latitude in degrees. It must be in the range [-90.0,
                                                            	// +90.0].
                                                            	Latitude float64 `json:"latitude,omitempty"`
                                                            
                                                            	// Longitude: The longitude in degrees. It must be in the range [-180.0,
                                                            	// +180.0].
                                                            	Longitude float64 `json:"longitude,omitempty"`
                                                            
                                                            	// ForceSendFields is a list of field names (e.g. "Latitude") to
                                                            	// unconditionally include in API requests. By default, fields with
                                                            	// empty values are omitted from API requests. However, any non-pointer,
                                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                                            	// server regardless of whether the field is empty or not. This may be
                                                            	// used to include empty fields in Patch requests.
                                                            	ForceSendFields []string `json:"-"`
                                                            
                                                            	// NullFields is a list of field names (e.g. "Latitude") to include in
                                                            	// API requests with the JSON null value. By default, fields with empty
                                                            	// values are omitted from API requests. However, any field with an
                                                            	// empty value appearing in NullFields will be sent to the server as
                                                            	// null. It is an error if a field in this list has a non-empty value.
                                                            	// This may be used to include null fields in Patch requests.
                                                            	NullFields []string `json:"-"`
                                                            }

                                                              LatLng: An object that represents a latitude/longitude pair. This is expressed as a pair of doubles to represent degrees latitude and degrees longitude. Unless specified otherwise, this must conform to the WGS84 standard. Values must be within normalized ranges.

                                                              func (*LatLng) MarshalJSON

                                                              func (s *LatLng) MarshalJSON() ([]byte, error)

                                                              func (*LatLng) UnmarshalJSON

                                                              func (s *LatLng) UnmarshalJSON(data []byte) error

                                                              type LookupRequest

                                                              type LookupRequest struct {
                                                              	// Keys: Required. Keys of entities to look up.
                                                              	Keys []*Key `json:"keys,omitempty"`
                                                              
                                                              	// ReadOptions: The options for this lookup request.
                                                              	ReadOptions *ReadOptions `json:"readOptions,omitempty"`
                                                              
                                                              	// ForceSendFields is a list of field names (e.g. "Keys") to
                                                              	// unconditionally include in API requests. By default, fields with
                                                              	// empty values are omitted from API requests. However, any non-pointer,
                                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                                              	// server regardless of whether the field is empty or not. This may be
                                                              	// used to include empty fields in Patch requests.
                                                              	ForceSendFields []string `json:"-"`
                                                              
                                                              	// NullFields is a list of field names (e.g. "Keys") to include in API
                                                              	// requests with the JSON null value. By default, fields with empty
                                                              	// values are omitted from API requests. However, any field with an
                                                              	// empty value appearing in NullFields will be sent to the server as
                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                              	// This may be used to include null fields in Patch requests.
                                                              	NullFields []string `json:"-"`
                                                              }

                                                                LookupRequest: The request for Datastore.Lookup.

                                                                func (*LookupRequest) MarshalJSON

                                                                func (s *LookupRequest) MarshalJSON() ([]byte, error)

                                                                type LookupResponse

                                                                type LookupResponse struct {
                                                                	// Deferred: A list of keys that were not looked up due to resource
                                                                	// constraints. The order of results in this field is undefined and has
                                                                	// no relation to the order of the keys in the input.
                                                                	Deferred []*Key `json:"deferred,omitempty"`
                                                                
                                                                	// Found: Entities found as `ResultType.FULL` entities. The order of
                                                                	// results in this field is undefined and has no relation to the order
                                                                	// of the keys in the input.
                                                                	Found []*EntityResult `json:"found,omitempty"`
                                                                
                                                                	// Missing: Entities not found as `ResultType.KEY_ONLY` entities. The
                                                                	// order of results in this field is undefined and has no relation to
                                                                	// the order of the keys in the input.
                                                                	Missing []*EntityResult `json:"missing,omitempty"`
                                                                
                                                                	// ServerResponse contains the HTTP response code and headers from the
                                                                	// server.
                                                                	googleapi.ServerResponse `json:"-"`
                                                                
                                                                	// ForceSendFields is a list of field names (e.g. "Deferred") to
                                                                	// unconditionally include in API requests. By default, fields with
                                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                                	// server regardless of whether the field is empty or not. This may be
                                                                	// used to include empty fields in Patch requests.
                                                                	ForceSendFields []string `json:"-"`
                                                                
                                                                	// NullFields is a list of field names (e.g. "Deferred") to include in
                                                                	// API requests with the JSON null value. By default, fields with empty
                                                                	// values are omitted from API requests. However, any field with an
                                                                	// empty value appearing in NullFields will be sent to the server as
                                                                	// null. It is an error if a field in this list has a non-empty value.
                                                                	// This may be used to include null fields in Patch requests.
                                                                	NullFields []string `json:"-"`
                                                                }

                                                                  LookupResponse: The response for Datastore.Lookup.

                                                                  func (*LookupResponse) MarshalJSON

                                                                  func (s *LookupResponse) MarshalJSON() ([]byte, error)

                                                                  type Mutation

                                                                  type Mutation struct {
                                                                  	// BaseVersion: The version of the entity that this mutation is being
                                                                  	// applied to. If this does not match the current version on the server,
                                                                  	// the mutation conflicts.
                                                                  	BaseVersion int64 `json:"baseVersion,omitempty,string"`
                                                                  
                                                                  	// Delete: The key of the entity to delete. The entity may or may not
                                                                  	// already exist. Must have a complete key path and must not be
                                                                  	// reserved/read-only.
                                                                  	Delete *Key `json:"delete,omitempty"`
                                                                  
                                                                  	// Insert: The entity to insert. The entity must not already exist. The
                                                                  	// entity key's final path element may be incomplete.
                                                                  	Insert *Entity `json:"insert,omitempty"`
                                                                  
                                                                  	// Update: The entity to update. The entity must already exist. Must
                                                                  	// have a complete key path.
                                                                  	Update *Entity `json:"update,omitempty"`
                                                                  
                                                                  	// Upsert: The entity to upsert. The entity may or may not already
                                                                  	// exist. The entity key's final path element may be incomplete.
                                                                  	Upsert *Entity `json:"upsert,omitempty"`
                                                                  
                                                                  	// ForceSendFields is a list of field names (e.g. "BaseVersion") to
                                                                  	// unconditionally include in API requests. By default, fields with
                                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                  	// used to include empty fields in Patch requests.
                                                                  	ForceSendFields []string `json:"-"`
                                                                  
                                                                  	// NullFields is a list of field names (e.g. "BaseVersion") to include
                                                                  	// in API requests with the JSON null value. By default, fields with
                                                                  	// empty values are omitted from API requests. However, any field with
                                                                  	// an empty value appearing in NullFields will be sent to the server as
                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                  	// This may be used to include null fields in Patch requests.
                                                                  	NullFields []string `json:"-"`
                                                                  }

                                                                    Mutation: A mutation to apply to an entity.

                                                                    func (*Mutation) MarshalJSON

                                                                    func (s *Mutation) MarshalJSON() ([]byte, error)

                                                                    type MutationResult

                                                                    type MutationResult struct {
                                                                    	// ConflictDetected: Whether a conflict was detected for this mutation.
                                                                    	// Always false when a conflict detection strategy field is not set in
                                                                    	// the mutation.
                                                                    	ConflictDetected bool `json:"conflictDetected,omitempty"`
                                                                    
                                                                    	// Key: The automatically allocated key. Set only when the mutation
                                                                    	// allocated a key.
                                                                    	Key *Key `json:"key,omitempty"`
                                                                    
                                                                    	// Version: The version of the entity on the server after processing the
                                                                    	// mutation. If the mutation doesn't change anything on the server, then
                                                                    	// the version will be the version of the current entity or, if no
                                                                    	// entity is present, a version that is strictly greater than the
                                                                    	// version of any previous entity and less than the version of any
                                                                    	// possible future entity.
                                                                    	Version int64 `json:"version,omitempty,string"`
                                                                    
                                                                    	// ForceSendFields is a list of field names (e.g. "ConflictDetected") to
                                                                    	// unconditionally include in API requests. By default, fields with
                                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                                    	// server regardless of whether the field is empty or not. This may be
                                                                    	// used to include empty fields in Patch requests.
                                                                    	ForceSendFields []string `json:"-"`
                                                                    
                                                                    	// NullFields is a list of field names (e.g. "ConflictDetected") to
                                                                    	// include in API requests with the JSON null value. By default, fields
                                                                    	// with empty values are omitted from API requests. However, any field
                                                                    	// with an empty value appearing in NullFields will be sent to the
                                                                    	// server as null. It is an error if a field in this list has a
                                                                    	// non-empty value. This may be used to include null fields in Patch
                                                                    	// requests.
                                                                    	NullFields []string `json:"-"`
                                                                    }

                                                                      MutationResult: The result of applying a mutation.

                                                                      func (*MutationResult) MarshalJSON

                                                                      func (s *MutationResult) MarshalJSON() ([]byte, error)

                                                                      type PartitionId

                                                                      type PartitionId struct {
                                                                      	// NamespaceId: If not empty, the ID of the namespace to which the
                                                                      	// entities belong.
                                                                      	NamespaceId string `json:"namespaceId,omitempty"`
                                                                      
                                                                      	// ProjectId: The ID of the project to which the entities belong.
                                                                      	ProjectId string `json:"projectId,omitempty"`
                                                                      
                                                                      	// ForceSendFields is a list of field names (e.g. "NamespaceId") to
                                                                      	// unconditionally include in API requests. By default, fields with
                                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                                      	// server regardless of whether the field is empty or not. This may be
                                                                      	// used to include empty fields in Patch requests.
                                                                      	ForceSendFields []string `json:"-"`
                                                                      
                                                                      	// NullFields is a list of field names (e.g. "NamespaceId") to include
                                                                      	// in API requests with the JSON null value. By default, fields with
                                                                      	// empty values are omitted from API requests. However, any field with
                                                                      	// an empty value appearing in NullFields will be sent to the server as
                                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                                      	// This may be used to include null fields in Patch requests.
                                                                      	NullFields []string `json:"-"`
                                                                      }

                                                                        PartitionId: A partition ID identifies a grouping of entities. The grouping is always by project and namespace, however the namespace ID may be empty. A partition ID contains several dimensions: project ID and namespace ID. Partition dimensions: - May be "". - Must be valid UTF-8 bytes. - Must have values that match regex `[A-Za-z\d\.\-_]{1,100}` If the value of any dimension matches regex `__.*__`, the partition is reserved/read-only. A reserved/read-only partition ID is forbidden in certain documented contexts. Foreign partition IDs (in which the project ID does not match the context project ID ) are discouraged. Reads and writes of foreign partition IDs may fail if the project is not in an active state.

                                                                        func (*PartitionId) MarshalJSON

                                                                        func (s *PartitionId) MarshalJSON() ([]byte, error)

                                                                        type PathElement

                                                                        type PathElement struct {
                                                                        	// Id: The auto-allocated ID of the entity. Never equal to zero. Values
                                                                        	// less than zero are discouraged and may not be supported in the
                                                                        	// future.
                                                                        	Id int64 `json:"id,omitempty,string"`
                                                                        
                                                                        	// Kind: The kind of the entity. A kind matching regex `__.*__` is
                                                                        	// reserved/read-only. A kind must not contain more than 1500 bytes when
                                                                        	// UTF-8 encoded. Cannot be "".
                                                                        	Kind string `json:"kind,omitempty"`
                                                                        
                                                                        	// Name: The name of the entity. A name matching regex `__.*__` is
                                                                        	// reserved/read-only. A name must not be more than 1500 bytes when
                                                                        	// UTF-8 encoded. Cannot be "".
                                                                        	Name string `json:"name,omitempty"`
                                                                        
                                                                        	// ForceSendFields is a list of field names (e.g. "Id") to
                                                                        	// unconditionally include in API requests. By default, fields with
                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                        	// used to include empty fields in Patch requests.
                                                                        	ForceSendFields []string `json:"-"`
                                                                        
                                                                        	// NullFields is a list of field names (e.g. "Id") to include in API
                                                                        	// requests with the JSON null value. By default, fields with empty
                                                                        	// values are omitted from API requests. However, any field with an
                                                                        	// empty value appearing in NullFields will be sent to the server as
                                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                                        	// This may be used to include null fields in Patch requests.
                                                                        	NullFields []string `json:"-"`
                                                                        }

                                                                          PathElement: A (kind, ID/name) pair used to construct a key path. If either name or ID is set, the element is complete. If neither is set, the element is incomplete.

                                                                          func (*PathElement) MarshalJSON

                                                                          func (s *PathElement) MarshalJSON() ([]byte, error)

                                                                          type Projection

                                                                          type Projection struct {
                                                                          	// Property: The property to project.
                                                                          	Property *PropertyReference `json:"property,omitempty"`
                                                                          
                                                                          	// ForceSendFields is a list of field names (e.g. "Property") to
                                                                          	// unconditionally include in API requests. By default, fields with
                                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                                          	// server regardless of whether the field is empty or not. This may be
                                                                          	// used to include empty fields in Patch requests.
                                                                          	ForceSendFields []string `json:"-"`
                                                                          
                                                                          	// NullFields is a list of field names (e.g. "Property") to include in
                                                                          	// API requests with the JSON null value. By default, fields with empty
                                                                          	// values are omitted from API requests. However, any field with an
                                                                          	// empty value appearing in NullFields will be sent to the server as
                                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                                          	// This may be used to include null fields in Patch requests.
                                                                          	NullFields []string `json:"-"`
                                                                          }

                                                                            Projection: A representation of a property in a projection.

                                                                            func (*Projection) MarshalJSON

                                                                            func (s *Projection) MarshalJSON() ([]byte, error)

                                                                            type ProjectsAllocateIdsCall

                                                                            type ProjectsAllocateIdsCall struct {
                                                                            	// contains filtered or unexported fields
                                                                            }

                                                                            func (*ProjectsAllocateIdsCall) Context

                                                                              Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                              func (*ProjectsAllocateIdsCall) Do

                                                                                Do executes the "datastore.projects.allocateIds" call. Exactly one of *AllocateIdsResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AllocateIdsResponse.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                func (*ProjectsAllocateIdsCall) Fields

                                                                                  Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                  func (*ProjectsAllocateIdsCall) Header

                                                                                  func (c *ProjectsAllocateIdsCall) Header() http.Header

                                                                                    Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                    type ProjectsBeginTransactionCall

                                                                                    type ProjectsBeginTransactionCall struct {
                                                                                    	// contains filtered or unexported fields
                                                                                    }

                                                                                    func (*ProjectsBeginTransactionCall) Context

                                                                                      Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                      func (*ProjectsBeginTransactionCall) Do

                                                                                        Do executes the "datastore.projects.beginTransaction" call. Exactly one of *BeginTransactionResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *BeginTransactionResponse.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                        func (*ProjectsBeginTransactionCall) Fields

                                                                                          Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                          func (*ProjectsBeginTransactionCall) Header

                                                                                            Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                            type ProjectsCommitCall

                                                                                            type ProjectsCommitCall struct {
                                                                                            	// contains filtered or unexported fields
                                                                                            }

                                                                                            func (*ProjectsCommitCall) Context

                                                                                              Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                              func (*ProjectsCommitCall) Do

                                                                                                Do executes the "datastore.projects.commit" call. Exactly one of *CommitResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *CommitResponse.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                func (*ProjectsCommitCall) Fields

                                                                                                  Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                  func (*ProjectsCommitCall) Header

                                                                                                  func (c *ProjectsCommitCall) Header() http.Header

                                                                                                    Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                    type ProjectsLookupCall

                                                                                                    type ProjectsLookupCall struct {
                                                                                                    	// contains filtered or unexported fields
                                                                                                    }

                                                                                                    func (*ProjectsLookupCall) Context

                                                                                                      Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                      func (*ProjectsLookupCall) Do

                                                                                                        Do executes the "datastore.projects.lookup" call. Exactly one of *LookupResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *LookupResponse.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                        func (*ProjectsLookupCall) Fields

                                                                                                          Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                          func (*ProjectsLookupCall) Header

                                                                                                          func (c *ProjectsLookupCall) Header() http.Header

                                                                                                            Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                            type ProjectsReserveIdsCall

                                                                                                            type ProjectsReserveIdsCall struct {
                                                                                                            	// contains filtered or unexported fields
                                                                                                            }

                                                                                                            func (*ProjectsReserveIdsCall) Context

                                                                                                              Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                              func (*ProjectsReserveIdsCall) Do

                                                                                                                Do executes the "datastore.projects.reserveIds" call. Exactly one of *ReserveIdsResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ReserveIdsResponse.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                func (*ProjectsReserveIdsCall) Fields

                                                                                                                  Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                  func (*ProjectsReserveIdsCall) Header

                                                                                                                  func (c *ProjectsReserveIdsCall) Header() http.Header

                                                                                                                    Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                    type ProjectsRollbackCall

                                                                                                                    type ProjectsRollbackCall struct {
                                                                                                                    	// contains filtered or unexported fields
                                                                                                                    }

                                                                                                                    func (*ProjectsRollbackCall) Context

                                                                                                                      Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                      func (*ProjectsRollbackCall) Do

                                                                                                                        Do executes the "datastore.projects.rollback" call. Exactly one of *RollbackResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *RollbackResponse.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                        func (*ProjectsRollbackCall) Fields

                                                                                                                          Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                          func (*ProjectsRollbackCall) Header

                                                                                                                          func (c *ProjectsRollbackCall) Header() http.Header

                                                                                                                            Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                            type ProjectsRunQueryCall

                                                                                                                            type ProjectsRunQueryCall struct {
                                                                                                                            	// contains filtered or unexported fields
                                                                                                                            }

                                                                                                                            func (*ProjectsRunQueryCall) Context

                                                                                                                              Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                              func (*ProjectsRunQueryCall) Do

                                                                                                                                Do executes the "datastore.projects.runQuery" call. Exactly one of *RunQueryResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *RunQueryResponse.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                func (*ProjectsRunQueryCall) Fields

                                                                                                                                  Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                  func (*ProjectsRunQueryCall) Header

                                                                                                                                  func (c *ProjectsRunQueryCall) Header() http.Header

                                                                                                                                    Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                    type ProjectsService

                                                                                                                                    type ProjectsService struct {
                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                    }

                                                                                                                                    func NewProjectsService

                                                                                                                                    func NewProjectsService(s *Service) *ProjectsService

                                                                                                                                    func (*ProjectsService) AllocateIds

                                                                                                                                    func (r *ProjectsService) AllocateIds(projectId string, allocateidsrequest *AllocateIdsRequest) *ProjectsAllocateIdsCall

                                                                                                                                      AllocateIds: Allocates IDs for the given keys, which is useful for referencing an entity before it is inserted.

                                                                                                                                      - projectId: The ID of the project against which to make the request.

                                                                                                                                      func (*ProjectsService) BeginTransaction

                                                                                                                                      func (r *ProjectsService) BeginTransaction(projectId string, begintransactionrequest *BeginTransactionRequest) *ProjectsBeginTransactionCall

                                                                                                                                        BeginTransaction: Begins a new transaction.

                                                                                                                                        - projectId: The ID of the project against which to make the request.

                                                                                                                                        func (*ProjectsService) Commit

                                                                                                                                        func (r *ProjectsService) Commit(projectId string, commitrequest *CommitRequest) *ProjectsCommitCall

                                                                                                                                          Commit: Commits a transaction, optionally creating, deleting or modifying some entities.

                                                                                                                                          - projectId: The ID of the project against which to make the request.

                                                                                                                                          func (*ProjectsService) Lookup

                                                                                                                                          func (r *ProjectsService) Lookup(projectId string, lookuprequest *LookupRequest) *ProjectsLookupCall

                                                                                                                                            Lookup: Looks up entities by key.

                                                                                                                                            - projectId: The ID of the project against which to make the request.

                                                                                                                                            func (*ProjectsService) ReserveIds

                                                                                                                                            func (r *ProjectsService) ReserveIds(projectId string, reserveidsrequest *ReserveIdsRequest) *ProjectsReserveIdsCall

                                                                                                                                              ReserveIds: Prevents the supplied keys' IDs from being auto-allocated by Cloud Datastore.

                                                                                                                                              - projectId: The ID of the project against which to make the request.

                                                                                                                                              func (*ProjectsService) Rollback

                                                                                                                                              func (r *ProjectsService) Rollback(projectId string, rollbackrequest *RollbackRequest) *ProjectsRollbackCall

                                                                                                                                                Rollback: Rolls back a transaction.

                                                                                                                                                - projectId: The ID of the project against which to make the request.

                                                                                                                                                func (*ProjectsService) RunQuery

                                                                                                                                                func (r *ProjectsService) RunQuery(projectId string, runqueryrequest *RunQueryRequest) *ProjectsRunQueryCall

                                                                                                                                                  RunQuery: Queries for entities.

                                                                                                                                                  - projectId: The ID of the project against which to make the request.

                                                                                                                                                  type PropertyFilter

                                                                                                                                                  type PropertyFilter struct {
                                                                                                                                                  	// Op: The operator to filter by.
                                                                                                                                                  	//
                                                                                                                                                  	// Possible values:
                                                                                                                                                  	//   "OPERATOR_UNSPECIFIED" - Unspecified. This value must not be used.
                                                                                                                                                  	//   "LESS_THAN" - Less than.
                                                                                                                                                  	//   "LESS_THAN_OR_EQUAL" - Less than or equal.
                                                                                                                                                  	//   "GREATER_THAN" - Greater than.
                                                                                                                                                  	//   "GREATER_THAN_OR_EQUAL" - Greater than or equal.
                                                                                                                                                  	//   "EQUAL" - Equal.
                                                                                                                                                  	//   "HAS_ANCESTOR" - Has ancestor.
                                                                                                                                                  	Op string `json:"op,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// Property: The property to filter by.
                                                                                                                                                  	Property *PropertyReference `json:"property,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// Value: The value to compare the property to.
                                                                                                                                                  	Value *Value `json:"value,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "Op") to
                                                                                                                                                  	// unconditionally include in API requests. By default, fields with
                                                                                                                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                  	// used to include empty fields in Patch requests.
                                                                                                                                                  	ForceSendFields []string `json:"-"`
                                                                                                                                                  
                                                                                                                                                  	// NullFields is a list of field names (e.g. "Op") to include in API
                                                                                                                                                  	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                  	// values are omitted from API requests. However, any field with an
                                                                                                                                                  	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                  	// This may be used to include null fields in Patch requests.
                                                                                                                                                  	NullFields []string `json:"-"`
                                                                                                                                                  }

                                                                                                                                                    PropertyFilter: A filter on a specific property.

                                                                                                                                                    func (*PropertyFilter) MarshalJSON

                                                                                                                                                    func (s *PropertyFilter) MarshalJSON() ([]byte, error)

                                                                                                                                                    type PropertyOrder

                                                                                                                                                    type PropertyOrder struct {
                                                                                                                                                    	// Direction: The direction to order by. Defaults to `ASCENDING`.
                                                                                                                                                    	//
                                                                                                                                                    	// Possible values:
                                                                                                                                                    	//   "DIRECTION_UNSPECIFIED" - Unspecified. This value must not be used.
                                                                                                                                                    	//   "ASCENDING" - Ascending.
                                                                                                                                                    	//   "DESCENDING" - Descending.
                                                                                                                                                    	Direction string `json:"direction,omitempty"`
                                                                                                                                                    
                                                                                                                                                    	// Property: The property to order by.
                                                                                                                                                    	Property *PropertyReference `json:"property,omitempty"`
                                                                                                                                                    
                                                                                                                                                    	// ForceSendFields is a list of field names (e.g. "Direction") to
                                                                                                                                                    	// unconditionally include in API requests. By default, fields with
                                                                                                                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                    	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                    	// used to include empty fields in Patch requests.
                                                                                                                                                    	ForceSendFields []string `json:"-"`
                                                                                                                                                    
                                                                                                                                                    	// NullFields is a list of field names (e.g. "Direction") to include in
                                                                                                                                                    	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                    	// values are omitted from API requests. However, any field with an
                                                                                                                                                    	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                    	// This may be used to include null fields in Patch requests.
                                                                                                                                                    	NullFields []string `json:"-"`
                                                                                                                                                    }

                                                                                                                                                      PropertyOrder: The desired order for a specific property.

                                                                                                                                                      func (*PropertyOrder) MarshalJSON

                                                                                                                                                      func (s *PropertyOrder) MarshalJSON() ([]byte, error)

                                                                                                                                                      type PropertyReference

                                                                                                                                                      type PropertyReference struct {
                                                                                                                                                      	// Name: The name of the property. If name includes "."s, it may be
                                                                                                                                                      	// interpreted as a property name path.
                                                                                                                                                      	Name string `json:"name,omitempty"`
                                                                                                                                                      
                                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "Name") to
                                                                                                                                                      	// unconditionally include in API requests. By default, fields with
                                                                                                                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                      	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                      	// used to include empty fields in Patch requests.
                                                                                                                                                      	ForceSendFields []string `json:"-"`
                                                                                                                                                      
                                                                                                                                                      	// NullFields is a list of field names (e.g. "Name") to include in API
                                                                                                                                                      	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                      	// values are omitted from API requests. However, any field with an
                                                                                                                                                      	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                      	// This may be used to include null fields in Patch requests.
                                                                                                                                                      	NullFields []string `json:"-"`
                                                                                                                                                      }

                                                                                                                                                        PropertyReference: A reference to a property relative to the kind expressions.

                                                                                                                                                        func (*PropertyReference) MarshalJSON

                                                                                                                                                        func (s *PropertyReference) MarshalJSON() ([]byte, error)

                                                                                                                                                        type Query

                                                                                                                                                        type Query struct {
                                                                                                                                                        	// DistinctOn: The properties to make distinct. The query results will
                                                                                                                                                        	// contain the first result for each distinct combination of values for
                                                                                                                                                        	// the given properties (if empty, all results are returned).
                                                                                                                                                        	DistinctOn []*PropertyReference `json:"distinctOn,omitempty"`
                                                                                                                                                        
                                                                                                                                                        	// EndCursor: An ending point for the query results. Query cursors are
                                                                                                                                                        	// returned in query result batches and can only be used to limit the
                                                                                                                                                        	// same query
                                                                                                                                                        	// (https://cloud.google.com/datastore/docs/concepts/queries#cursors_limits_and_offsets).
                                                                                                                                                        	EndCursor string `json:"endCursor,omitempty"`
                                                                                                                                                        
                                                                                                                                                        	// Filter: The filter to apply.
                                                                                                                                                        	Filter *Filter `json:"filter,omitempty"`
                                                                                                                                                        
                                                                                                                                                        	// Kind: The kinds to query (if empty, returns entities of all kinds).
                                                                                                                                                        	// Currently at most 1 kind may be specified.
                                                                                                                                                        	Kind []*KindExpression `json:"kind,omitempty"`
                                                                                                                                                        
                                                                                                                                                        	// Limit: The maximum number of results to return. Applies after all
                                                                                                                                                        	// other constraints. Optional. Unspecified is interpreted as no limit.
                                                                                                                                                        	// Must be >= 0 if specified.
                                                                                                                                                        	Limit int64 `json:"limit,omitempty"`
                                                                                                                                                        
                                                                                                                                                        	// Offset: The number of results to skip. Applies before limit, but
                                                                                                                                                        	// after all other constraints. Optional. Must be >= 0 if specified.
                                                                                                                                                        	Offset int64 `json:"offset,omitempty"`
                                                                                                                                                        
                                                                                                                                                        	// Order: The order to apply to the query results (if empty, order is
                                                                                                                                                        	// unspecified).
                                                                                                                                                        	Order []*PropertyOrder `json:"order,omitempty"`
                                                                                                                                                        
                                                                                                                                                        	// Projection: The projection to return. Defaults to returning all
                                                                                                                                                        	// properties.
                                                                                                                                                        	Projection []*Projection `json:"projection,omitempty"`
                                                                                                                                                        
                                                                                                                                                        	// StartCursor: A starting point for the query results. Query cursors
                                                                                                                                                        	// are returned in query result batches and can only be used to continue
                                                                                                                                                        	// the same query
                                                                                                                                                        	// (https://cloud.google.com/datastore/docs/concepts/queries#cursors_limits_and_offsets).
                                                                                                                                                        	StartCursor string `json:"startCursor,omitempty"`
                                                                                                                                                        
                                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "DistinctOn") to
                                                                                                                                                        	// unconditionally include in API requests. By default, fields with
                                                                                                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                        	// used to include empty fields in Patch requests.
                                                                                                                                                        	ForceSendFields []string `json:"-"`
                                                                                                                                                        
                                                                                                                                                        	// NullFields is a list of field names (e.g. "DistinctOn") to include in
                                                                                                                                                        	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                        	// values are omitted from API requests. However, any field with an
                                                                                                                                                        	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                        	// This may be used to include null fields in Patch requests.
                                                                                                                                                        	NullFields []string `json:"-"`
                                                                                                                                                        }

                                                                                                                                                          Query: A query for entities.

                                                                                                                                                          func (*Query) MarshalJSON

                                                                                                                                                          func (s *Query) MarshalJSON() ([]byte, error)

                                                                                                                                                          type QueryResultBatch

                                                                                                                                                          type QueryResultBatch struct {
                                                                                                                                                          	// EndCursor: A cursor that points to the position after the last result
                                                                                                                                                          	// in the batch.
                                                                                                                                                          	EndCursor string `json:"endCursor,omitempty"`
                                                                                                                                                          
                                                                                                                                                          	// EntityResultType: The result type for every entity in
                                                                                                                                                          	// `entity_results`.
                                                                                                                                                          	//
                                                                                                                                                          	// Possible values:
                                                                                                                                                          	//   "RESULT_TYPE_UNSPECIFIED" - Unspecified. This value is never used.
                                                                                                                                                          	//   "FULL" - The key and properties.
                                                                                                                                                          	//   "PROJECTION" - A projected subset of properties. The entity may
                                                                                                                                                          	// have no key.
                                                                                                                                                          	//   "KEY_ONLY" - Only the key.
                                                                                                                                                          	EntityResultType string `json:"entityResultType,omitempty"`
                                                                                                                                                          
                                                                                                                                                          	// EntityResults: The results for this batch.
                                                                                                                                                          	EntityResults []*EntityResult `json:"entityResults,omitempty"`
                                                                                                                                                          
                                                                                                                                                          	// MoreResults: The state of the query after the current batch.
                                                                                                                                                          	//
                                                                                                                                                          	// Possible values:
                                                                                                                                                          	//   "MORE_RESULTS_TYPE_UNSPECIFIED" - Unspecified. This value is never
                                                                                                                                                          	// used.
                                                                                                                                                          	//   "NOT_FINISHED" - There may be additional batches to fetch from this
                                                                                                                                                          	// query.
                                                                                                                                                          	//   "MORE_RESULTS_AFTER_LIMIT" - The query is finished, but there may
                                                                                                                                                          	// be more results after the limit.
                                                                                                                                                          	//   "MORE_RESULTS_AFTER_CURSOR" - The query is finished, but there may
                                                                                                                                                          	// be more results after the end cursor.
                                                                                                                                                          	//   "NO_MORE_RESULTS" - The query is finished, and there are no more
                                                                                                                                                          	// results.
                                                                                                                                                          	MoreResults string `json:"moreResults,omitempty"`
                                                                                                                                                          
                                                                                                                                                          	// SkippedCursor: A cursor that points to the position after the last
                                                                                                                                                          	// skipped result. Will be set when `skipped_results` != 0.
                                                                                                                                                          	SkippedCursor string `json:"skippedCursor,omitempty"`
                                                                                                                                                          
                                                                                                                                                          	// SkippedResults: The number of results skipped, typically because of
                                                                                                                                                          	// an offset.
                                                                                                                                                          	SkippedResults int64 `json:"skippedResults,omitempty"`
                                                                                                                                                          
                                                                                                                                                          	// SnapshotVersion: The version number of the snapshot this batch was
                                                                                                                                                          	// returned from. This applies to the range of results from the query's
                                                                                                                                                          	// `start_cursor` (or the beginning of the query if no cursor was given)
                                                                                                                                                          	// to this batch's `end_cursor` (not the query's `end_cursor`). In a
                                                                                                                                                          	// single transaction, subsequent query result batches for the same
                                                                                                                                                          	// query can have a greater snapshot version number. Each batch's
                                                                                                                                                          	// snapshot version is valid for all preceding batches. The value will
                                                                                                                                                          	// be zero for eventually consistent queries.
                                                                                                                                                          	SnapshotVersion int64 `json:"snapshotVersion,omitempty,string"`
                                                                                                                                                          
                                                                                                                                                          	// ForceSendFields is a list of field names (e.g. "EndCursor") to
                                                                                                                                                          	// unconditionally include in API requests. By default, fields with
                                                                                                                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                          	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                          	// used to include empty fields in Patch requests.
                                                                                                                                                          	ForceSendFields []string `json:"-"`
                                                                                                                                                          
                                                                                                                                                          	// NullFields is a list of field names (e.g. "EndCursor") to include in
                                                                                                                                                          	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                          	// values are omitted from API requests. However, any field with an
                                                                                                                                                          	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                          	// This may be used to include null fields in Patch requests.
                                                                                                                                                          	NullFields []string `json:"-"`
                                                                                                                                                          }

                                                                                                                                                            QueryResultBatch: A batch of results produced by a query.

                                                                                                                                                            func (*QueryResultBatch) MarshalJSON

                                                                                                                                                            func (s *QueryResultBatch) MarshalJSON() ([]byte, error)

                                                                                                                                                            type ReadOnly

                                                                                                                                                            type ReadOnly struct {
                                                                                                                                                            }

                                                                                                                                                              ReadOnly: Options specific to read-only transactions.

                                                                                                                                                              type ReadOptions

                                                                                                                                                              type ReadOptions struct {
                                                                                                                                                              	// ReadConsistency: The non-transactional read consistency to use.
                                                                                                                                                              	// Cannot be set to `STRONG` for global queries.
                                                                                                                                                              	//
                                                                                                                                                              	// Possible values:
                                                                                                                                                              	//   "READ_CONSISTENCY_UNSPECIFIED" - Unspecified. This value must not
                                                                                                                                                              	// be used.
                                                                                                                                                              	//   "STRONG" - Strong consistency.
                                                                                                                                                              	//   "EVENTUAL" - Eventual consistency.
                                                                                                                                                              	ReadConsistency string `json:"readConsistency,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// Transaction: The identifier of the transaction in which to read. A
                                                                                                                                                              	// transaction identifier is returned by a call to
                                                                                                                                                              	// Datastore.BeginTransaction.
                                                                                                                                                              	Transaction string `json:"transaction,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "ReadConsistency") to
                                                                                                                                                              	// unconditionally include in API requests. By default, fields with
                                                                                                                                                              	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                              	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                              	// used to include empty fields in Patch requests.
                                                                                                                                                              	ForceSendFields []string `json:"-"`
                                                                                                                                                              
                                                                                                                                                              	// NullFields is a list of field names (e.g. "ReadConsistency") to
                                                                                                                                                              	// include in API requests with the JSON null value. By default, fields
                                                                                                                                                              	// with empty values are omitted from API requests. However, any field
                                                                                                                                                              	// with an empty value appearing in NullFields will be sent to the
                                                                                                                                                              	// server as null. It is an error if a field in this list has a
                                                                                                                                                              	// non-empty value. This may be used to include null fields in Patch
                                                                                                                                                              	// requests.
                                                                                                                                                              	NullFields []string `json:"-"`
                                                                                                                                                              }

                                                                                                                                                                ReadOptions: The options shared by read requests.

                                                                                                                                                                func (*ReadOptions) MarshalJSON

                                                                                                                                                                func (s *ReadOptions) MarshalJSON() ([]byte, error)

                                                                                                                                                                type ReadWrite

                                                                                                                                                                type ReadWrite struct {
                                                                                                                                                                	// PreviousTransaction: The transaction identifier of the transaction
                                                                                                                                                                	// being retried.
                                                                                                                                                                	PreviousTransaction string `json:"previousTransaction,omitempty"`
                                                                                                                                                                
                                                                                                                                                                	// ForceSendFields is a list of field names (e.g. "PreviousTransaction")
                                                                                                                                                                	// to unconditionally include in API requests. By default, fields with
                                                                                                                                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                	// used to include empty fields in Patch requests.
                                                                                                                                                                	ForceSendFields []string `json:"-"`
                                                                                                                                                                
                                                                                                                                                                	// NullFields is a list of field names (e.g. "PreviousTransaction") to
                                                                                                                                                                	// include in API requests with the JSON null value. By default, fields
                                                                                                                                                                	// with empty values are omitted from API requests. However, any field
                                                                                                                                                                	// with an empty value appearing in NullFields will be sent to the
                                                                                                                                                                	// server as null. It is an error if a field in this list has a
                                                                                                                                                                	// non-empty value. This may be used to include null fields in Patch
                                                                                                                                                                	// requests.
                                                                                                                                                                	NullFields []string `json:"-"`
                                                                                                                                                                }

                                                                                                                                                                  ReadWrite: Options specific to read / write transactions.

                                                                                                                                                                  func (*ReadWrite) MarshalJSON

                                                                                                                                                                  func (s *ReadWrite) MarshalJSON() ([]byte, error)

                                                                                                                                                                  type ReserveIdsRequest

                                                                                                                                                                  type ReserveIdsRequest struct {
                                                                                                                                                                  	// DatabaseId: If not empty, the ID of the database against which to
                                                                                                                                                                  	// make the request.
                                                                                                                                                                  	DatabaseId string `json:"databaseId,omitempty"`
                                                                                                                                                                  
                                                                                                                                                                  	// Keys: Required. A list of keys with complete key paths whose numeric
                                                                                                                                                                  	// IDs should not be auto-allocated.
                                                                                                                                                                  	Keys []*Key `json:"keys,omitempty"`
                                                                                                                                                                  
                                                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "DatabaseId") to
                                                                                                                                                                  	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                  	// used to include empty fields in Patch requests.
                                                                                                                                                                  	ForceSendFields []string `json:"-"`
                                                                                                                                                                  
                                                                                                                                                                  	// NullFields is a list of field names (e.g. "DatabaseId") to include in
                                                                                                                                                                  	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                                  	// values are omitted from API requests. However, any field with an
                                                                                                                                                                  	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                  	// This may be used to include null fields in Patch requests.
                                                                                                                                                                  	NullFields []string `json:"-"`
                                                                                                                                                                  }

                                                                                                                                                                    ReserveIdsRequest: The request for Datastore.ReserveIds.

                                                                                                                                                                    func (*ReserveIdsRequest) MarshalJSON

                                                                                                                                                                    func (s *ReserveIdsRequest) MarshalJSON() ([]byte, error)

                                                                                                                                                                    type ReserveIdsResponse

                                                                                                                                                                    type ReserveIdsResponse struct {
                                                                                                                                                                    	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                    	// server.
                                                                                                                                                                    	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                    }

                                                                                                                                                                      ReserveIdsResponse: The response for Datastore.ReserveIds.

                                                                                                                                                                      type RollbackRequest

                                                                                                                                                                      type RollbackRequest struct {
                                                                                                                                                                      	// Transaction: Required. The transaction identifier, returned by a call
                                                                                                                                                                      	// to Datastore.BeginTransaction.
                                                                                                                                                                      	Transaction string `json:"transaction,omitempty"`
                                                                                                                                                                      
                                                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "Transaction") to
                                                                                                                                                                      	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                      	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                      	// used to include empty fields in Patch requests.
                                                                                                                                                                      	ForceSendFields []string `json:"-"`
                                                                                                                                                                      
                                                                                                                                                                      	// NullFields is a list of field names (e.g. "Transaction") to include
                                                                                                                                                                      	// in API requests with the JSON null value. By default, fields with
                                                                                                                                                                      	// empty values are omitted from API requests. However, any field with
                                                                                                                                                                      	// an empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                      	// This may be used to include null fields in Patch requests.
                                                                                                                                                                      	NullFields []string `json:"-"`
                                                                                                                                                                      }

                                                                                                                                                                        RollbackRequest: The request for Datastore.Rollback.

                                                                                                                                                                        func (*RollbackRequest) MarshalJSON

                                                                                                                                                                        func (s *RollbackRequest) MarshalJSON() ([]byte, error)

                                                                                                                                                                        type RollbackResponse

                                                                                                                                                                        type RollbackResponse struct {
                                                                                                                                                                        	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                        	// server.
                                                                                                                                                                        	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                        }

                                                                                                                                                                          RollbackResponse: The response for Datastore.Rollback. (an empty message).

                                                                                                                                                                          type RunQueryRequest

                                                                                                                                                                          type RunQueryRequest struct {
                                                                                                                                                                          	// GqlQuery: The GQL query to run.
                                                                                                                                                                          	GqlQuery *GqlQuery `json:"gqlQuery,omitempty"`
                                                                                                                                                                          
                                                                                                                                                                          	// PartitionId: Entities are partitioned into subsets, identified by a
                                                                                                                                                                          	// partition ID. Queries are scoped to a single partition. This
                                                                                                                                                                          	// partition ID is normalized with the standard default context
                                                                                                                                                                          	// partition ID.
                                                                                                                                                                          	PartitionId *PartitionId `json:"partitionId,omitempty"`
                                                                                                                                                                          
                                                                                                                                                                          	// Query: The query to run.
                                                                                                                                                                          	Query *Query `json:"query,omitempty"`
                                                                                                                                                                          
                                                                                                                                                                          	// ReadOptions: The options for this query.
                                                                                                                                                                          	ReadOptions *ReadOptions `json:"readOptions,omitempty"`
                                                                                                                                                                          
                                                                                                                                                                          	// ForceSendFields is a list of field names (e.g. "GqlQuery") to
                                                                                                                                                                          	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                          	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                          	// used to include empty fields in Patch requests.
                                                                                                                                                                          	ForceSendFields []string `json:"-"`
                                                                                                                                                                          
                                                                                                                                                                          	// NullFields is a list of field names (e.g. "GqlQuery") to include in
                                                                                                                                                                          	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                                          	// values are omitted from API requests. However, any field with an
                                                                                                                                                                          	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                          	// This may be used to include null fields in Patch requests.
                                                                                                                                                                          	NullFields []string `json:"-"`
                                                                                                                                                                          }

                                                                                                                                                                            RunQueryRequest: The request for Datastore.RunQuery.

                                                                                                                                                                            func (*RunQueryRequest) MarshalJSON

                                                                                                                                                                            func (s *RunQueryRequest) MarshalJSON() ([]byte, error)

                                                                                                                                                                            type RunQueryResponse

                                                                                                                                                                            type RunQueryResponse struct {
                                                                                                                                                                            	// Batch: A batch of query results (always present).
                                                                                                                                                                            	Batch *QueryResultBatch `json:"batch,omitempty"`
                                                                                                                                                                            
                                                                                                                                                                            	// Query: The parsed form of the `GqlQuery` from the request, if it was
                                                                                                                                                                            	// set.
                                                                                                                                                                            	Query *Query `json:"query,omitempty"`
                                                                                                                                                                            
                                                                                                                                                                            	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                            	// server.
                                                                                                                                                                            	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                            
                                                                                                                                                                            	// ForceSendFields is a list of field names (e.g. "Batch") to
                                                                                                                                                                            	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                            	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                            	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                            	// used to include empty fields in Patch requests.
                                                                                                                                                                            	ForceSendFields []string `json:"-"`
                                                                                                                                                                            
                                                                                                                                                                            	// NullFields is a list of field names (e.g. "Batch") to include in API
                                                                                                                                                                            	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                                            	// values are omitted from API requests. However, any field with an
                                                                                                                                                                            	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                            	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                            	// This may be used to include null fields in Patch requests.
                                                                                                                                                                            	NullFields []string `json:"-"`
                                                                                                                                                                            }

                                                                                                                                                                              RunQueryResponse: The response for Datastore.RunQuery.

                                                                                                                                                                              func (*RunQueryResponse) MarshalJSON

                                                                                                                                                                              func (s *RunQueryResponse) MarshalJSON() ([]byte, error)

                                                                                                                                                                              type Service

                                                                                                                                                                              type Service struct {
                                                                                                                                                                              	BasePath  string // API endpoint base URL
                                                                                                                                                                              	UserAgent string // optional additional User-Agent fragment
                                                                                                                                                                              
                                                                                                                                                                              	Projects *ProjectsService
                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                              }

                                                                                                                                                                              func New

                                                                                                                                                                              func New(client *http.Client) (*Service, error)

                                                                                                                                                                                New creates a new Service. It uses the provided http.Client for requests.

                                                                                                                                                                                Deprecated: please use NewService instead. To provide a custom HTTP client, use option.WithHTTPClient. If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead.

                                                                                                                                                                                func NewService

                                                                                                                                                                                func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error)

                                                                                                                                                                                  NewService creates a new Service.

                                                                                                                                                                                  type TransactionOptions

                                                                                                                                                                                  type TransactionOptions struct {
                                                                                                                                                                                  	// ReadOnly: The transaction should only allow reads.
                                                                                                                                                                                  	ReadOnly *ReadOnly `json:"readOnly,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// ReadWrite: The transaction should allow both reads and writes.
                                                                                                                                                                                  	ReadWrite *ReadWrite `json:"readWrite,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "ReadOnly") to
                                                                                                                                                                                  	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                  	// used to include empty fields in Patch requests.
                                                                                                                                                                                  	ForceSendFields []string `json:"-"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// NullFields is a list of field names (e.g. "ReadOnly") to include in
                                                                                                                                                                                  	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                  	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                  	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                  	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                  	NullFields []string `json:"-"`
                                                                                                                                                                                  }

                                                                                                                                                                                    TransactionOptions: Options for beginning a new transaction. Transactions can be created explicitly with calls to Datastore.BeginTransaction or implicitly by setting ReadOptions.new_transaction in read requests.

                                                                                                                                                                                    func (*TransactionOptions) MarshalJSON

                                                                                                                                                                                    func (s *TransactionOptions) MarshalJSON() ([]byte, error)

                                                                                                                                                                                    type Value

                                                                                                                                                                                    type Value struct {
                                                                                                                                                                                    	// ArrayValue: An array value. Cannot contain another array value. A
                                                                                                                                                                                    	// `Value` instance that sets field `array_value` must not set fields
                                                                                                                                                                                    	// `meaning` or `exclude_from_indexes`.
                                                                                                                                                                                    	ArrayValue *ArrayValue `json:"arrayValue,omitempty"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// BlobValue: A blob value. May have at most 1,000,000 bytes. When
                                                                                                                                                                                    	// `exclude_from_indexes` is false, may have at most 1500 bytes. In JSON
                                                                                                                                                                                    	// requests, must be base64-encoded.
                                                                                                                                                                                    	BlobValue *string `json:"blobValue,omitempty"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// BooleanValue: A boolean value.
                                                                                                                                                                                    	BooleanValue *bool `json:"booleanValue,omitempty"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// DoubleValue: A double value.
                                                                                                                                                                                    	DoubleValue *float64 `json:"doubleValue,omitempty"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// EntityValue: An entity value. - May have no key. - May have a key
                                                                                                                                                                                    	// with an incomplete key path. - May have a reserved/read-only key.
                                                                                                                                                                                    	EntityValue *Entity `json:"entityValue,omitempty"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// ExcludeFromIndexes: If the value should be excluded from all indexes
                                                                                                                                                                                    	// including those defined explicitly.
                                                                                                                                                                                    	ExcludeFromIndexes bool `json:"excludeFromIndexes,omitempty"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// GeoPointValue: A geo point value representing a point on the surface
                                                                                                                                                                                    	// of Earth.
                                                                                                                                                                                    	GeoPointValue *LatLng `json:"geoPointValue,omitempty"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// IntegerValue: An integer value.
                                                                                                                                                                                    	IntegerValue *int64 `json:"integerValue,omitempty,string"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// KeyValue: A key value.
                                                                                                                                                                                    	KeyValue *Key `json:"keyValue,omitempty"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// Meaning: The `meaning` field should only be populated for backwards
                                                                                                                                                                                    	// compatibility.
                                                                                                                                                                                    	Meaning int64 `json:"meaning,omitempty"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// NullValue: A null value.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// Possible values:
                                                                                                                                                                                    	//   "NULL_VALUE" - Null value.
                                                                                                                                                                                    	NullValue string `json:"nullValue,omitempty"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// StringValue: A UTF-8 encoded string value. When
                                                                                                                                                                                    	// `exclude_from_indexes` is false (it is indexed) , may have at most
                                                                                                                                                                                    	// 1500 bytes. Otherwise, may be set to at most 1,000,000 bytes.
                                                                                                                                                                                    	StringValue *string `json:"stringValue,omitempty"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// TimestampValue: A timestamp value. When stored in the Datastore,
                                                                                                                                                                                    	// precise only to microseconds; any additional precision is rounded
                                                                                                                                                                                    	// down.
                                                                                                                                                                                    	TimestampValue *string `json:"timestampValue,omitempty"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// ForceSendFields is a list of field names (e.g. "ArrayValue") to
                                                                                                                                                                                    	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                    	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                    	// used to include empty fields in Patch requests.
                                                                                                                                                                                    	ForceSendFields []string `json:"-"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// NullFields is a list of field names (e.g. "ArrayValue") to include in
                                                                                                                                                                                    	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                    	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                    	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                    	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                    	NullFields []string `json:"-"`
                                                                                                                                                                                    }

                                                                                                                                                                                      Value: A message that can hold any of the supported value types and associated metadata.

                                                                                                                                                                                      func (*Value) MarshalJSON

                                                                                                                                                                                      func (s *Value) MarshalJSON() ([]byte, error)

                                                                                                                                                                                      func (*Value) UnmarshalJSON

                                                                                                                                                                                      func (s *Value) UnmarshalJSON(data []byte) error