Api-roll 41: 2016-08-26

generated/googleapis_beta/lib/datastore/v1beta3.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis_beta.datastore.v1beta3;
 
 import 'dart:core' as core;
 import 'dart:async' as async;
 import 'dart:convert' as convert;
 
 import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
 import 'package:http/http.dart' as http;
@@ skipping 293 matching lines @@
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new RunQueryResponse.fromJson(data));
   }
 
 }
 
 
 
-/** The request for google.datastore.v1beta3.Datastore.AllocateIds. */
+/** The request for Datastore.AllocateIds. */
 class AllocateIdsRequest {
   /**
    * A list of keys with incomplete key paths for which to allocate IDs.
    * No key may be reserved/read-only.
    */
   core.List<Key> keys;
 
   AllocateIdsRequest();
 
   AllocateIdsRequest.fromJson(core.Map _json) {
     if (_json.containsKey("keys")) {
       keys = _json["keys"].map((value) => new Key.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (keys != null) {
       _json["keys"] = keys.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
-/** The response for google.datastore.v1beta3.Datastore.AllocateIds. */
+/** The response for Datastore.AllocateIds. */
 class AllocateIdsResponse {
   /**
    * The keys specified in the request (in the same order), each with
    * its key path completed with a newly allocated ID.
    */
   core.List<Key> keys;
 
   AllocateIdsResponse();
 
   AllocateIdsResponse.fromJson(core.Map _json) {
@@ skipping 30 matching lines @@
 
   core.Map toJson() {
     var _json = new core.Map();
     if (values != null) {
       _json["values"] = values.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
-/** The request for google.datastore.v1beta3.Datastore.BeginTransaction. */
+/** The request for Datastore.BeginTransaction. */
 class BeginTransactionRequest {
 
   BeginTransactionRequest();
 
   BeginTransactionRequest.fromJson(core.Map _json) {
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     return _json;
   }
 }
 
-/** The response for google.datastore.v1beta3.Datastore.BeginTransaction. */
+/** The response for Datastore.BeginTransaction. */
 class BeginTransactionResponse {
   /** The transaction identifier (always present). */
   core.String transaction;
   core.List<core.int> get transactionAsBytes {
     return convert.BASE64.decode(transaction);
   }
 
   void set transactionAsBytes(core.List<core.int> _bytes) {
     transaction = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
 
   BeginTransactionResponse();
 
   BeginTransactionResponse.fromJson(core.Map _json) {
     if (_json.containsKey("transaction")) {
       transaction = _json["transaction"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (transaction != null) {
       _json["transaction"] = transaction;
     }
     return _json;
   }
 }
 
-/** The request for google.datastore.v1beta3.Datastore.Commit. */
+/** The request for Datastore.Commit. */
 class CommitRequest {
   /**
    * The type of commit to perform. Defaults to `TRANSACTIONAL`.
    * Possible string values are:
    * - "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
@@ skipping 12 matching lines @@
    * - `upsert` followed by `insert`
    * - `delete` followed by `update`
    *
    * When mode is `NON_TRANSACTIONAL`, no two mutations may affect a single
    * entity.
    */
   core.List<Mutation> mutations;
   /**
    * The identifier of the transaction associated with the commit. A
    * transaction identifier is returned by a call to
-   * BeginTransaction.
+   * Datastore.BeginTransaction.
    */
   core.String transaction;
   core.List<core.int> get transactionAsBytes {
     return convert.BASE64.decode(transaction);
   }
 
   void set transactionAsBytes(core.List<core.int> _bytes) {
     transaction = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
 
@@ skipping 19 matching lines @@
     if (mutations != null) {
       _json["mutations"] = mutations.map((value) => (value).toJson()).toList();
     }
     if (transaction != null) {
       _json["transaction"] = transaction;
     }
     return _json;
   }
 }
 
-/** The response for google.datastore.v1beta3.Datastore.Commit. */
+/** The response for Datastore.Commit. */
 class CommitResponse {
   /**
    * The number of index entries updated during the commit, or zero if none were
    * updated.
    */
   core.int indexUpdates;
   /**
    * The result of performing the mutations.
    * The i-th mutation result corresponds to the i-th mutation in the request.
    */
@@ skipping 119 matching lines @@
   core.String cursor;
   core.List<core.int> get cursorAsBytes {
     return convert.BASE64.decode(cursor);
   }
 
   void set cursorAsBytes(core.List<core.int> _bytes) {
     cursor = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /** The resulting entity. */
   Entity entity;
+  /**
+   * 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.
+   */
+  core.String version;
 
   EntityResult();
 
   EntityResult.fromJson(core.Map _json) {
     if (_json.containsKey("cursor")) {
       cursor = _json["cursor"];
     }
     if (_json.containsKey("entity")) {
       entity = new Entity.fromJson(_json["entity"]);
     }
+    if (_json.containsKey("version")) {
+      version = _json["version"];
+    }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (cursor != null) {
       _json["cursor"] = cursor;
     }
     if (entity != null) {
       _json["entity"] = (entity).toJson();
     }
+    if (version != null) {
+      _json["version"] = version;
+    }
     return _json;
   }
 }
 
 /** A holder for any type of filter. */
 class Filter {
   /** A composite filter. */
   CompositeFilter compositeFilter;
   /** A filter on a property. */
   PropertyFilter propertyFilter;
@@ skipping 20 matching lines @@
     return _json;
   }
 }
 
 /**
  * A [GQL
  * query](https://cloud.google.com/datastore/docs/apis/gql/gql_reference).
  */
 class GqlQuery {
   /**
-   * When false, the query string must not contain any literals and instead
-   * must bind all values. For example,
+   * 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.
    */
   core.bool allowLiterals;
   /**
-   * 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.
+   * 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 `""`.
    */
   core.Map<core.String, GqlQueryParameter> namedBindings;
   /**
    * 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.
+   *
+   * For each binding site numbered i in `query_string`, there must be an i-th
+   * numbered parameter. The inverse must also be true.
    */
   core.List<GqlQueryParameter> positionalBindings;
   /**
    * A string of the format described
    * [here](https://cloud.google.com/datastore/docs/apis/gql/gql_reference).
    */
   core.String queryString;
 
   GqlQuery();
 
@@ skipping 211 matching lines @@
     if (latitude != null) {
       _json["latitude"] = latitude;
     }
     if (longitude != null) {
       _json["longitude"] = longitude;
     }
     return _json;
   }
 }
 
-/** The request for google.datastore.v1beta3.Datastore.Lookup. */
+/** The request for Datastore.Lookup. */
 class LookupRequest {
   /** Keys of entities to look up. */
   core.List<Key> keys;
   /** The options for this lookup request. */
   ReadOptions readOptions;
 
   LookupRequest();
 
   LookupRequest.fromJson(core.Map _json) {
     if (_json.containsKey("keys")) {
       keys = _json["keys"].map((value) => new Key.fromJson(value)).toList();
     }
     if (_json.containsKey("readOptions")) {
       readOptions = new ReadOptions.fromJson(_json["readOptions"]);
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (keys != null) {
       _json["keys"] = keys.map((value) => (value).toJson()).toList();
     }
     if (readOptions != null) {
       _json["readOptions"] = (readOptions).toJson();
     }
     return _json;
   }
 }
 
-/** The response for google.datastore.v1beta3.Datastore.Lookup. */
+/** The response for Datastore.Lookup. */
 class LookupResponse {
   /**
    * 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.
    */
   core.List<Key> deferred;
   /**
    * 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
@@ skipping 32 matching lines @@
     if (missing != null) {
       _json["missing"] = missing.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /** A mutation to apply to an entity. */
 class Mutation {
   /**
+   * 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.
+   */
+  core.String baseVersion;
+  /**
    * 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.
    */
   Key delete;
   /**
    * The entity to insert. The entity must not already exist.
    * The entity key's final path element may be incomplete.
    */
   Entity insert;
   /**
    * The entity to update. The entity must already exist.
    * Must have a complete key path.
    */
   Entity update;
   /**
    * The entity to upsert. The entity may or may not already exist.
    * The entity key's final path element may be incomplete.
    */
   Entity upsert;
 
   Mutation();
 
   Mutation.fromJson(core.Map _json) {
+    if (_json.containsKey("baseVersion")) {
+      baseVersion = _json["baseVersion"];
+    }
     if (_json.containsKey("delete")) {
       delete = new Key.fromJson(_json["delete"]);
     }
     if (_json.containsKey("insert")) {
       insert = new Entity.fromJson(_json["insert"]);
     }
     if (_json.containsKey("update")) {
       update = new Entity.fromJson(_json["update"]);
     }
     if (_json.containsKey("upsert")) {
       upsert = new Entity.fromJson(_json["upsert"]);
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
+    if (baseVersion != null) {
+      _json["baseVersion"] = baseVersion;
+    }
     if (delete != null) {
       _json["delete"] = (delete).toJson();
     }
     if (insert != null) {
       _json["insert"] = (insert).toJson();
     }
     if (update != null) {
       _json["update"] = (update).toJson();
     }
     if (upsert != null) {
       _json["upsert"] = (upsert).toJson();
     }
     return _json;
   }
 }
 
 /** The result of applying a mutation. */
 class MutationResult {
   /**
+   * Whether a conflict was detected for this mutation. Always false when a
+   * conflict detection strategy field is not set in the mutation.
+   */
+  core.bool conflictDetected;
+  /**
    * The automatically allocated key.
    * Set only when the mutation allocated a key.
    */
   Key key;
+  /**
+   * 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.
+   */
+  core.String version;
 
   MutationResult();
 
   MutationResult.fromJson(core.Map _json) {
+    if (_json.containsKey("conflictDetected")) {
+      conflictDetected = _json["conflictDetected"];
+    }
     if (_json.containsKey("key")) {
       key = new Key.fromJson(_json["key"]);
     }
+    if (_json.containsKey("version")) {
+      version = _json["version"];
+    }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
+    if (conflictDetected != null) {
+      _json["conflictDetected"] = conflictDetected;
+    }
     if (key != null) {
       _json["key"] = (key).toJson();
     }
+    if (version != null) {
+      _json["version"] = version;
+    }
     return _json;
   }
 }
 
 /**
  * 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.
@@ skipping 384 matching lines @@
   core.List<EntityResult> entityResults;
   /**
    * The state of the query after the current batch.
    * Possible string values are:
    * - "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.
+   * more results after the end
+   * cursor.
    * - "NO_MORE_RESULTS" : The query has been exhausted.
    */
   core.String moreResults;
   /**
    * A cursor that points to the position after the last skipped result.
    * Will be set when `skipped_results` != 0.
    */
   core.String skippedCursor;
   core.List<core.int> get skippedCursorAsBytes {
     return convert.BASE64.decode(skippedCursor);
   }
 
   void set skippedCursorAsBytes(core.List<core.int> _bytes) {
     skippedCursor = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /** The number of results skipped, typically because of an offset. */
   core.int skippedResults;
+  /**
+   * 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.
+   */
+  core.String snapshotVersion;
 
   QueryResultBatch();
 
   QueryResultBatch.fromJson(core.Map _json) {
     if (_json.containsKey("endCursor")) {
       endCursor = _json["endCursor"];
     }
     if (_json.containsKey("entityResultType")) {
       entityResultType = _json["entityResultType"];
     }
     if (_json.containsKey("entityResults")) {
       entityResults = _json["entityResults"].map((value) => new EntityResult.fromJson(value)).toList();
     }
     if (_json.containsKey("moreResults")) {
       moreResults = _json["moreResults"];
     }
     if (_json.containsKey("skippedCursor")) {
       skippedCursor = _json["skippedCursor"];
     }
     if (_json.containsKey("skippedResults")) {
       skippedResults = _json["skippedResults"];
     }
+    if (_json.containsKey("snapshotVersion")) {
+      snapshotVersion = _json["snapshotVersion"];
+    }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (endCursor != null) {
       _json["endCursor"] = endCursor;
     }
     if (entityResultType != null) {
       _json["entityResultType"] = entityResultType;
     }
     if (entityResults != null) {
       _json["entityResults"] = entityResults.map((value) => (value).toJson()).toList();
     }
     if (moreResults != null) {
       _json["moreResults"] = moreResults;
     }
     if (skippedCursor != null) {
       _json["skippedCursor"] = skippedCursor;
     }
     if (skippedResults != null) {
       _json["skippedResults"] = skippedResults;
     }
+    if (snapshotVersion != null) {
+      _json["snapshotVersion"] = snapshotVersion;
+    }
     return _json;
   }
 }
 
 /** The options shared by read requests. */
 class ReadOptions {
   /**
    * The non-transactional read consistency to use.
    * Cannot be set to `STRONG` for global queries.
    * Possible string values are:
    * - "READ_CONSISTENCY_UNSPECIFIED" : Unspecified. This value must not be
    * used.
    * - "STRONG" : Strong consistency.
    * - "EVENTUAL" : Eventual consistency.
    */
   core.String readConsistency;
   /**
    * The identifier of the transaction in which to read. A
    * transaction identifier is returned by a call to
-   * BeginTransaction.
+   * Datastore.BeginTransaction.
    */
   core.String transaction;
   core.List<core.int> get transactionAsBytes {
     return convert.BASE64.decode(transaction);
   }
 
   void set transactionAsBytes(core.List<core.int> _bytes) {
     transaction = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
 
@@ skipping 13 matching lines @@
     if (readConsistency != null) {
       _json["readConsistency"] = readConsistency;
     }
     if (transaction != null) {
       _json["transaction"] = transaction;
     }
     return _json;
   }
 }
 
-/** The request for google.datastore.v1beta3.Datastore.Rollback. */
+/** The request for Datastore.Rollback. */
 class RollbackRequest {
   /**
    * The transaction identifier, returned by a call to
-   * google.datastore.v1beta3.Datastore.BeginTransaction.
+   * Datastore.BeginTransaction.
    */
   core.String transaction;
   core.List<core.int> get transactionAsBytes {
     return convert.BASE64.decode(transaction);
   }
 
   void set transactionAsBytes(core.List<core.int> _bytes) {
     transaction = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
 
   RollbackRequest();
 
   RollbackRequest.fromJson(core.Map _json) {
     if (_json.containsKey("transaction")) {
       transaction = _json["transaction"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (transaction != null) {
       _json["transaction"] = transaction;
     }
     return _json;
   }
 }
 
 /**
- * The response for google.datastore.v1beta3.Datastore.Rollback
+ * The response for Datastore.Rollback.
  * (an empty message).
  */
 class RollbackResponse {
 
   RollbackResponse();
 
   RollbackResponse.fromJson(core.Map _json) {
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     return _json;
   }
 }
 
-/** The request for google.datastore.v1beta3.Datastore.RunQuery. */
+/** The request for Datastore.RunQuery. */
 class RunQueryRequest {
   /** The GQL query to run. */
   GqlQuery gqlQuery;
   /**
    * 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;
@@ skipping 30 matching lines @@
     if (query != null) {
       _json["query"] = (query).toJson();
     }
     if (readOptions != null) {
       _json["readOptions"] = (readOptions).toJson();
     }
     return _json;
   }
 }
 
-/** The response for google.datastore.v1beta3.Datastore.RunQuery. */
+/** The response for Datastore.RunQuery. */
 class RunQueryResponse {
   /** A batch of query results (always present). */
   QueryResultBatch batch;
   /** The parsed form of the `GqlQuery` from the request, if it was set. */
   Query query;
 
   RunQueryResponse();
 
   RunQueryResponse.fromJson(core.Map _json) {
     if (_json.containsKey("batch")) {
@@ skipping 170 matching lines @@
     }
     if (stringValue != null) {
       _json["stringValue"] = stringValue;
     }
     if (timestampValue != null) {
       _json["timestampValue"] = timestampValue;
     }
     return _json;
   }
 }