Generate 0.1.0 version of googleapis/googleapis_beta

generated/googleapis_beta/lib/datastore/v1beta2.dart

+library googleapis_beta.datastore.v1beta2;
+
+import "dart:core" as core;
+import "dart:collection" as collection;
+import "dart:async" as async;
+import "dart:convert" as convert;
+
+import "package:crypto/crypto.dart" as crypto;
+import 'package:http/http.dart' as http;
+import '../src/common_internal.dart' as common_internal;
+import '../common/common.dart' as common;
+
+export '../common/common.dart' show ApiRequestError;
+export '../common/common.dart' show DetailedApiRequestError;
+
+/** API for accessing Google Cloud Datastore. */
+class DatastoreApi {
+  /** View and manage your Google Cloud Datastore data */
+  static const DatastoreScope = "https://www.googleapis.com/auth/datastore";
+
+  /** View your email address */
+  static const UserinfoEmailScope = "https://www.googleapis.com/auth/userinfo.email";
+
+
+  final common_internal.ApiRequester _requester;
+
+  DatasetsResourceApi get datasets => new DatasetsResourceApi(_requester);
+
+  DatastoreApi(http.Client client) : 
+      _requester = new common_internal.ApiRequester(client, "https://www.googleapis.com/", "/datastore/v1beta2/datasets/");
+}
+
+
+/** Not documented yet. */
+class DatasetsResourceApi {
+  final common_internal.ApiRequester _requester;
+
+  DatasetsResourceApi(common_internal.ApiRequester client) : 
+      _requester = client;
+
+  /**
+   * Allocate IDs for incomplete keys (useful for referencing an entity before
+   * it is inserted).
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * [datasetId] - Identifies the dataset.
+   *
+   * Completes with a [AllocateIdsResponse].
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future<AllocateIdsResponse> allocateIds(AllocateIdsRequest request, core.String datasetId) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (request != null) {
+      _body = convert.JSON.encode((request).toJson());
+    }
+    if (datasetId == null) {
+      throw new core.ArgumentError("Parameter datasetId is required.");
+    }
+
+
+    _url = common_internal.Escaper.ecapeVariable('$datasetId') + '/allocateIds';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new AllocateIdsResponse.fromJson(data));
+  }
+
+  /**
+   * Begin a new transaction.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * [datasetId] - Identifies the dataset.
+   *
+   * Completes with a [BeginTransactionResponse].
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future<BeginTransactionResponse> beginTransaction(BeginTransactionRequest request, core.String datasetId) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (request != null) {
+      _body = convert.JSON.encode((request).toJson());
+    }
+    if (datasetId == null) {
+      throw new core.ArgumentError("Parameter datasetId is required.");
+    }
+
+
+    _url = common_internal.Escaper.ecapeVariable('$datasetId') + '/beginTransaction';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new BeginTransactionResponse.fromJson(data));
+  }
+
+  /**
+   * Commit a transaction, optionally creating, deleting or modifying some
+   * entities.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * [datasetId] - Identifies the dataset.
+   *
+   * Completes with a [CommitResponse].
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future<CommitResponse> commit(CommitRequest request, core.String datasetId) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (request != null) {
+      _body = convert.JSON.encode((request).toJson());
+    }
+    if (datasetId == null) {
+      throw new core.ArgumentError("Parameter datasetId is required.");
+    }
+
+
+    _url = common_internal.Escaper.ecapeVariable('$datasetId') + '/commit';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new CommitResponse.fromJson(data));
+  }
+
+  /**
+   * Look up some entities by key.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * [datasetId] - Identifies the dataset.
+   *
+   * Completes with a [LookupResponse].
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future<LookupResponse> lookup(LookupRequest request, core.String datasetId) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (request != null) {
+      _body = convert.JSON.encode((request).toJson());
+    }
+    if (datasetId == null) {
+      throw new core.ArgumentError("Parameter datasetId is required.");
+    }
+
+
+    _url = common_internal.Escaper.ecapeVariable('$datasetId') + '/lookup';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new LookupResponse.fromJson(data));
+  }
+
+  /**
+   * Roll back a transaction.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * [datasetId] - Identifies the dataset.
+   *
+   * Completes with a [RollbackResponse].
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future<RollbackResponse> rollback(RollbackRequest request, core.String datasetId) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (request != null) {
+      _body = convert.JSON.encode((request).toJson());
+    }
+    if (datasetId == null) {
+      throw new core.ArgumentError("Parameter datasetId is required.");
+    }
+
+
+    _url = common_internal.Escaper.ecapeVariable('$datasetId') + '/rollback';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new RollbackResponse.fromJson(data));
+  }
+
+  /**
+   * Query for entities.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * [datasetId] - Identifies the dataset.
+   *
+   * Completes with a [RunQueryResponse].
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future<RunQueryResponse> runQuery(RunQueryRequest request, core.String datasetId) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (request != null) {
+      _body = convert.JSON.encode((request).toJson());
+    }
+    if (datasetId == null) {
+      throw new core.ArgumentError("Parameter datasetId is required.");
+    }
+
+
+    _url = common_internal.Escaper.ecapeVariable('$datasetId') + '/runQuery';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new RunQueryResponse.fromJson(data));
+  }
+
+}
+
+
+
+/** Not documented yet. */
+class AllocateIdsRequest {
+  /**
+   * A list of keys with incomplete key paths to allocate IDs for. 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;
+  }
+}
+
+
+/** Not documented yet. */
+class AllocateIdsResponse {
+  /** Not documented yet. */
+  ResponseHeader header;
+
+  /**
+   * 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) {
+    if (_json.containsKey("header")) {
+      header = new ResponseHeader.fromJson(_json["header"]);
+    }
+    if (_json.containsKey("keys")) {
+      keys = _json["keys"].map((value) => new Key.fromJson(value)).toList();
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (header != null) {
+      _json["header"] = (header).toJson();
+    }
+    if (keys != null) {
+      _json["keys"] = keys.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class BeginTransactionRequest {
+  /**
+   * The transaction isolation level. Either snapshot or serializable. The
+   * default isolation level is snapshot isolation, which means that another
+   * transaction may not concurrently modify the data that is modified by this
+   * transaction. Optionally, a transaction can request to be made serializable
+   * which means that another transaction cannot concurrently modify the data
+   * that is read or modified by this transaction.
+   * Possible string values are:
+   * - "SERIALIZABLE"
+   * - "SNAPSHOT"
+   */
+  core.String isolationLevel;
+
+
+  BeginTransactionRequest();
+
+  BeginTransactionRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("isolationLevel")) {
+      isolationLevel = _json["isolationLevel"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (isolationLevel != null) {
+      _json["isolationLevel"] = isolationLevel;
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class BeginTransactionResponse {
+  /** Not documented yet. */
+  ResponseHeader header;
+
+  /** The transaction identifier (always present). */
+  core.String transaction;
+
+  core.List<core.int> get transactionAsBytes {
+    return crypto.CryptoUtils.base64StringToBytes(transaction);
+  }
+
+  void set transactionAsBytes(core.List<core.int> _bytes) {
+    transaction = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+  }
+
+
+  BeginTransactionResponse();
+
+  BeginTransactionResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("header")) {
+      header = new ResponseHeader.fromJson(_json["header"]);
+    }
+    if (_json.containsKey("transaction")) {
+      transaction = _json["transaction"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (header != null) {
+      _json["header"] = (header).toJson();
+    }
+    if (transaction != null) {
+      _json["transaction"] = transaction;
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class CommitRequest {
+  /** Not documented yet. */
+  core.bool ignoreReadOnly;
+
+  /**
+   * The type of commit to perform. Either TRANSACTIONAL or NON_TRANSACTIONAL.
+   * Possible string values are:
+   * - "NON_TRANSACTIONAL"
+   * - "TRANSACTIONAL"
+   */
+  core.String mode;
+
+  /** The mutation to perform. Optional. */
+  Mutation mutation;
+
+  /**
+   * The transaction identifier, returned by a call to beginTransaction. Must be
+   * set when mode is TRANSACTIONAL.
+   */
+  core.String transaction;
+
+  core.List<core.int> get transactionAsBytes {
+    return crypto.CryptoUtils.base64StringToBytes(transaction);
+  }
+
+  void set transactionAsBytes(core.List<core.int> _bytes) {
+    transaction = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+  }
+
+
+  CommitRequest();
+
+  CommitRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("ignoreReadOnly")) {
+      ignoreReadOnly = _json["ignoreReadOnly"];
+    }
+    if (_json.containsKey("mode")) {
+      mode = _json["mode"];
+    }
+    if (_json.containsKey("mutation")) {
+      mutation = new Mutation.fromJson(_json["mutation"]);
+    }
+    if (_json.containsKey("transaction")) {
+      transaction = _json["transaction"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (ignoreReadOnly != null) {
+      _json["ignoreReadOnly"] = ignoreReadOnly;
+    }
+    if (mode != null) {
+      _json["mode"] = mode;
+    }
+    if (mutation != null) {
+      _json["mutation"] = (mutation).toJson();
+    }
+    if (transaction != null) {
+      _json["transaction"] = transaction;
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class CommitResponse {
+  /** Not documented yet. */
+  ResponseHeader header;
+
+  /** The result of performing the mutation (if any). */
+  MutationResult mutationResult;
+
+
+  CommitResponse();
+
+  CommitResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("header")) {
+      header = new ResponseHeader.fromJson(_json["header"]);
+    }
+    if (_json.containsKey("mutationResult")) {
+      mutationResult = new MutationResult.fromJson(_json["mutationResult"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (header != null) {
+      _json["header"] = (header).toJson();
+    }
+    if (mutationResult != null) {
+      _json["mutationResult"] = (mutationResult).toJson();
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class CompositeFilter {
+  /** The list of filters to combine. Must contain at least one filter. */
+  core.List<Filter> filters;
+
+  /**
+   * The operator for combining multiple filters. Only "and" is currently
+   * supported.
+   * Possible string values are:
+   * - "AND"
+   */
+  core.String operator;
+
+
+  CompositeFilter();
+
+  CompositeFilter.fromJson(core.Map _json) {
+    if (_json.containsKey("filters")) {
+      filters = _json["filters"].map((value) => new Filter.fromJson(value)).toList();
+    }
+    if (_json.containsKey("operator")) {
+      operator = _json["operator"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (filters != null) {
+      _json["filters"] = filters.map((value) => (value).toJson()).toList();
+    }
+    if (operator != null) {
+      _json["operator"] = operator;
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class Entity {
+  /**
+   * The entity's key.
+   *
+   * An entity must have a key, unless otherwise documented (for example, an
+   * entity in Value.entityValue may have no key). An entity's kind is its key's
+   * path's last element's kind, or null if it has no key.
+   */
+  Key key;
+
+  /** The entity's properties. */
+  core.Map<core.String, Property> properties;
+
+
+  Entity();
+
+  Entity.fromJson(core.Map _json) {
+    if (_json.containsKey("key")) {
+      key = new Key.fromJson(_json["key"]);
+    }
+    if (_json.containsKey("properties")) {
+      properties = common_internal.mapMap(_json["properties"], (item) => new Property.fromJson(item));
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (key != null) {
+      _json["key"] = (key).toJson();
+    }
+    if (properties != null) {
+      _json["properties"] = common_internal.mapMap(properties, (item) => (item).toJson());
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class EntityResult {
+  /** The resulting entity. */
+  Entity entity;
+
+
+  EntityResult();
+
+  EntityResult.fromJson(core.Map _json) {
+    if (_json.containsKey("entity")) {
+      entity = new Entity.fromJson(_json["entity"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (entity != null) {
+      _json["entity"] = (entity).toJson();
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class Filter {
+  /** A composite filter. */
+  CompositeFilter compositeFilter;
+
+  /** A filter on a property. */
+  PropertyFilter propertyFilter;
+
+
+  Filter();
+
+  Filter.fromJson(core.Map _json) {
+    if (_json.containsKey("compositeFilter")) {
+      compositeFilter = new CompositeFilter.fromJson(_json["compositeFilter"]);
+    }
+    if (_json.containsKey("propertyFilter")) {
+      propertyFilter = new PropertyFilter.fromJson(_json["propertyFilter"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (compositeFilter != null) {
+      _json["compositeFilter"] = (compositeFilter).toJson();
+    }
+    if (propertyFilter != null) {
+      _json["propertyFilter"] = (propertyFilter).toJson();
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class GqlQuery {
+  /** When false, the query string must not contain a literal. */
+  core.bool allowLiteral;
+
+  /**
+   * A named argument must set field GqlQueryArg.name. No two named arguments
+   * may have the same name. For each non-reserved named binding site in the
+   * query string, there must be a named argument with that name, but not
+   * necessarily the inverse.
+   */
+  core.List<GqlQueryArg> nameArgs;
+
+  /**
+   * Numbered binding site @1 references the first numbered argument,
+   * effectively using 1-based indexing, rather than the usual 0. A numbered
+   * argument must NOT set field GqlQueryArg.name. For each binding site
+   * numbered i in query_string, there must be an ith numbered argument. The
+   * inverse must also be true.
+   */
+  core.List<GqlQueryArg> numberArgs;
+
+  /** Not documented yet. */
+  core.String queryString;
+
+
+  GqlQuery();
+
+  GqlQuery.fromJson(core.Map _json) {
+    if (_json.containsKey("allowLiteral")) {
+      allowLiteral = _json["allowLiteral"];
+    }
+    if (_json.containsKey("nameArgs")) {
+      nameArgs = _json["nameArgs"].map((value) => new GqlQueryArg.fromJson(value)).toList();
+    }
+    if (_json.containsKey("numberArgs")) {
+      numberArgs = _json["numberArgs"].map((value) => new GqlQueryArg.fromJson(value)).toList();
+    }
+    if (_json.containsKey("queryString")) {
+      queryString = _json["queryString"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (allowLiteral != null) {
+      _json["allowLiteral"] = allowLiteral;
+    }
+    if (nameArgs != null) {
+      _json["nameArgs"] = nameArgs.map((value) => (value).toJson()).toList();
+    }
+    if (numberArgs != null) {
+      _json["numberArgs"] = numberArgs.map((value) => (value).toJson()).toList();
+    }
+    if (queryString != null) {
+      _json["queryString"] = queryString;
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class GqlQueryArg {
+  /** Not documented yet. */
+  core.String cursor;
+
+  core.List<core.int> get cursorAsBytes {
+    return crypto.CryptoUtils.base64StringToBytes(cursor);
+  }
+
+  void set cursorAsBytes(core.List<core.int> _bytes) {
+    cursor = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+  }
+
+  /**
+   * Must match regex "[A-Za-z_$][A-Za-z_$0-9]*". Must not match regex "__.*__".
+   * Must not be "".
+   */
+  core.String name;
+
+  /** Not documented yet. */
+  Value value;
+
+
+  GqlQueryArg();
+
+  GqlQueryArg.fromJson(core.Map _json) {
+    if (_json.containsKey("cursor")) {
+      cursor = _json["cursor"];
+    }
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+    if (_json.containsKey("value")) {
+      value = new Value.fromJson(_json["value"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (cursor != null) {
+      _json["cursor"] = cursor;
+    }
+    if (name != null) {
+      _json["name"] = name;
+    }
+    if (value != null) {
+      _json["value"] = (value).toJson();
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class Key {
+  /**
+   * Entities are partitioned into subsets, currently identified by a dataset
+   * (usually implicitly specified by the project) and namespace ID. Queries are
+   * scoped to a single partition.
+   */
+  PartitionId partitionId;
+
+  /**
+   * 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 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. A path can never be empty. The path can have at most 100
+   * elements.
+   */
+  core.List<KeyPathElement> path;
+
+
+  Key();
+
+  Key.fromJson(core.Map _json) {
+    if (_json.containsKey("partitionId")) {
+      partitionId = new PartitionId.fromJson(_json["partitionId"]);
+    }
+    if (_json.containsKey("path")) {
+      path = _json["path"].map((value) => new KeyPathElement.fromJson(value)).toList();
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (partitionId != null) {
+      _json["partitionId"] = (partitionId).toJson();
+    }
+    if (path != null) {
+      _json["path"] = path.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+
+/**
+ * A (kind, ID/name) pair used to construct a key path.
+ *
+ * At most one of name or ID may be set. If either is set, the element is
+ * complete. If neither is set, the element is incomplete.
+ */
+class KeyPathElement {
+  /**
+   * The ID of the entity. Never equal to zero. Values less than zero are
+   * discouraged and will not be supported in the future.
+   */
+  core.String id;
+
+  /**
+   * The kind of the entity. A kind matching regex "__.*__" is
+   * reserved/read-only. A kind must not contain more than 500 characters.
+   * Cannot be "".
+   */
+  core.String kind;
+
+  /**
+   * The name of the entity. A name matching regex "__.*__" is
+   * reserved/read-only. A name must not be more than 500 characters. Cannot be
+   * "".
+   */
+  core.String name;
+
+
+  KeyPathElement();
+
+  KeyPathElement.fromJson(core.Map _json) {
+    if (_json.containsKey("id")) {
+      id = _json["id"];
+    }
+    if (_json.containsKey("kind")) {
+      kind = _json["kind"];
+    }
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (id != null) {
+      _json["id"] = id;
+    }
+    if (kind != null) {
+      _json["kind"] = kind;
+    }
+    if (name != null) {
+      _json["name"] = name;
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class KindExpression {
+  /** The name of the kind. */
+  core.String name;
+
+
+  KindExpression();
+
+  KindExpression.fromJson(core.Map _json) {
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (name != null) {
+      _json["name"] = name;
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class LookupRequest {
+  /** Keys of entities to look up from the datastore. */
+  core.List<Key> keys;
+
+  /** Options for this lookup request. Optional. */
+  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;
+  }
+}
+
+
+/** Not documented yet. */
+class LookupResponse {
+  /** A list of keys that were not looked up due to resource constraints. */
+  core.List<Key> deferred;
+
+  /** Entities found. */
+  core.List<EntityResult> found;
+
+  /** Not documented yet. */
+  ResponseHeader header;
+
+  /** Entities not found, with only the key populated. */
+  core.List<EntityResult> missing;
+
+
+  LookupResponse();
+
+  LookupResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("deferred")) {
+      deferred = _json["deferred"].map((value) => new Key.fromJson(value)).toList();
+    }
+    if (_json.containsKey("found")) {
+      found = _json["found"].map((value) => new EntityResult.fromJson(value)).toList();
+    }
+    if (_json.containsKey("header")) {
+      header = new ResponseHeader.fromJson(_json["header"]);
+    }
+    if (_json.containsKey("missing")) {
+      missing = _json["missing"].map((value) => new EntityResult.fromJson(value)).toList();
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (deferred != null) {
+      _json["deferred"] = deferred.map((value) => (value).toJson()).toList();
+    }
+    if (found != null) {
+      _json["found"] = found.map((value) => (value).toJson()).toList();
+    }
+    if (header != null) {
+      _json["header"] = (header).toJson();
+    }
+    if (missing != null) {
+      _json["missing"] = missing.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class Mutation {
+  /**
+   * Keys of entities to delete. Each key must have a complete key path and must
+   * not be reserved/read-only.
+   */
+  core.List<Key> delete;
+
+  /** Ignore a user specified read-only period. Optional. */
+  core.bool force;
+
+  /**
+   * Entities to insert. Each inserted entity's key must have a complete path
+   * and must not be reserved/read-only.
+   */
+  core.List<Entity> insert;
+
+  /**
+   * Insert entities with a newly allocated ID. Each inserted entity's key must
+   * omit the final identifier in its path and must not be reserved/read-only.
+   */
+  core.List<Entity> insertAutoId;
+
+  /**
+   * Entities to update. Each updated entity's key must have a complete path and
+   * must not be reserved/read-only.
+   */
+  core.List<Entity> update;
+
+  /**
+   * Entities to upsert. Each upserted entity's key must have a complete path
+   * and must not be reserved/read-only.
+   */
+  core.List<Entity> upsert;
+
+
+  Mutation();
+
+  Mutation.fromJson(core.Map _json) {
+    if (_json.containsKey("delete")) {
+      delete = _json["delete"].map((value) => new Key.fromJson(value)).toList();
+    }
+    if (_json.containsKey("force")) {
+      force = _json["force"];
+    }
+    if (_json.containsKey("insert")) {
+      insert = _json["insert"].map((value) => new Entity.fromJson(value)).toList();
+    }
+    if (_json.containsKey("insertAutoId")) {
+      insertAutoId = _json["insertAutoId"].map((value) => new Entity.fromJson(value)).toList();
+    }
+    if (_json.containsKey("update")) {
+      update = _json["update"].map((value) => new Entity.fromJson(value)).toList();
+    }
+    if (_json.containsKey("upsert")) {
+      upsert = _json["upsert"].map((value) => new Entity.fromJson(value)).toList();
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (delete != null) {
+      _json["delete"] = delete.map((value) => (value).toJson()).toList();
+    }
+    if (force != null) {
+      _json["force"] = force;
+    }
+    if (insert != null) {
+      _json["insert"] = insert.map((value) => (value).toJson()).toList();
+    }
+    if (insertAutoId != null) {
+      _json["insertAutoId"] = insertAutoId.map((value) => (value).toJson()).toList();
+    }
+    if (update != null) {
+      _json["update"] = update.map((value) => (value).toJson()).toList();
+    }
+    if (upsert != null) {
+      _json["upsert"] = upsert.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class MutationResult {
+  /** Number of index writes. */
+  core.int indexUpdates;
+
+  /**
+   * Keys for insertAutoId entities. One per entity from the request, in the
+   * same order.
+   */
+  core.List<Key> insertAutoIdKeys;
+
+
+  MutationResult();
+
+  MutationResult.fromJson(core.Map _json) {
+    if (_json.containsKey("indexUpdates")) {
+      indexUpdates = _json["indexUpdates"];
+    }
+    if (_json.containsKey("insertAutoIdKeys")) {
+      insertAutoIdKeys = _json["insertAutoIdKeys"].map((value) => new Key.fromJson(value)).toList();
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (indexUpdates != null) {
+      _json["indexUpdates"] = indexUpdates;
+    }
+    if (insertAutoIdKeys != null) {
+      _json["insertAutoIdKeys"] = insertAutoIdKeys.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class PartitionId {
+  /** The dataset ID. */
+  core.String datasetId;
+
+  /** The namespace. */
+  core.String namespace;
+
+
+  PartitionId();
+
+  PartitionId.fromJson(core.Map _json) {
+    if (_json.containsKey("datasetId")) {
+      datasetId = _json["datasetId"];
+    }
+    if (_json.containsKey("namespace")) {
+      namespace = _json["namespace"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (datasetId != null) {
+      _json["datasetId"] = datasetId;
+    }
+    if (namespace != null) {
+      _json["namespace"] = namespace;
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class Property {
+  /** A blob key value. */
+  core.String blobKeyValue;
+
+  /** A blob value. May be a maximum of 1,000,000 bytes. */
+  core.String blobValue;
+
+  core.List<core.int> get blobValueAsBytes {
+    return crypto.CryptoUtils.base64StringToBytes(blobValue);
+  }
+
+  void set blobValueAsBytes(core.List<core.int> _bytes) {
+    blobValue = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+  }
+
+  /** A boolean value. */
+  core.bool booleanValue;
+
+  /** A timestamp value. */
+  core.DateTime dateTimeValue;
+
+  /** A double value. */
+  core.double doubleValue;
+
+  /**
+   * An entity value. May have no key. May have a key with an incomplete key
+   * path. May have a reserved/read-only key.
+   */
+  Entity entityValue;
+
+  /**
+   * If the value should be indexed.
+   *
+   * The indexed property may be set for a null value. When indexed is true,
+   * stringValue is limited to 500 characters and the blob value is limited to
+   * 500 bytes. Input values by default have indexed set to true; however, you
+   * can explicitly set indexed to true if you want. (An output value never has
+   * indexed explicitly set to true.) If a value is itself an entity, it cannot
+   * have indexed set to true.
+   */
+  core.bool indexed;
+
+  /** An integer value. */
+  core.String integerValue;
+
+  /** A key value. */
+  Key keyValue;
+
+  /**
+   * A list value. Cannot contain another list value. Cannot also have a meaning
+   * and indexing set.
+   */
+  core.List<Value> listValue;
+
+  /** The meaning field is reserved and should not be used. */
+  core.int meaning;
+
+  /** A UTF-8 encoded string value. */
+  core.String stringValue;
+
+
+  Property();
+
+  Property.fromJson(core.Map _json) {
+    if (_json.containsKey("blobKeyValue")) {
+      blobKeyValue = _json["blobKeyValue"];
+    }
+    if (_json.containsKey("blobValue")) {
+      blobValue = _json["blobValue"];
+    }
+    if (_json.containsKey("booleanValue")) {
+      booleanValue = _json["booleanValue"];
+    }
+    if (_json.containsKey("dateTimeValue")) {
+      dateTimeValue = core.DateTime.parse(_json["dateTimeValue"]);
+    }
+    if (_json.containsKey("doubleValue")) {
+      doubleValue = _json["doubleValue"];
+    }
+    if (_json.containsKey("entityValue")) {
+      entityValue = new Entity.fromJson(_json["entityValue"]);
+    }
+    if (_json.containsKey("indexed")) {
+      indexed = _json["indexed"];
+    }
+    if (_json.containsKey("integerValue")) {
+      integerValue = _json["integerValue"];
+    }
+    if (_json.containsKey("keyValue")) {
+      keyValue = new Key.fromJson(_json["keyValue"]);
+    }
+    if (_json.containsKey("listValue")) {
+      listValue = _json["listValue"].map((value) => new Value.fromJson(value)).toList();
+    }
+    if (_json.containsKey("meaning")) {
+      meaning = _json["meaning"];
+    }
+    if (_json.containsKey("stringValue")) {
+      stringValue = _json["stringValue"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (blobKeyValue != null) {
+      _json["blobKeyValue"] = blobKeyValue;
+    }
+    if (blobValue != null) {
+      _json["blobValue"] = blobValue;
+    }
+    if (booleanValue != null) {
+      _json["booleanValue"] = booleanValue;
+    }
+    if (dateTimeValue != null) {
+      _json["dateTimeValue"] = (dateTimeValue).toIso8601String();
+    }
+    if (doubleValue != null) {
+      _json["doubleValue"] = doubleValue;
+    }
+    if (entityValue != null) {
+      _json["entityValue"] = (entityValue).toJson();
+    }
+    if (indexed != null) {
+      _json["indexed"] = indexed;
+    }
+    if (integerValue != null) {
+      _json["integerValue"] = integerValue;
+    }
+    if (keyValue != null) {
+      _json["keyValue"] = (keyValue).toJson();
+    }
+    if (listValue != null) {
+      _json["listValue"] = listValue.map((value) => (value).toJson()).toList();
+    }
+    if (meaning != null) {
+      _json["meaning"] = meaning;
+    }
+    if (stringValue != null) {
+      _json["stringValue"] = stringValue;
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class PropertyExpression {
+  /**
+   * The aggregation function to apply to the property. Optional. Can only be
+   * used when grouping by at least one property. Must then be set on all
+   * properties in the projection that are not being grouped by. Aggregation
+   * functions: first selects the first result as determined by the query's
+   * order.
+   * Possible string values are:
+   * - "FIRST"
+   */
+  core.String aggregationFunction;
+
+  /** The property to project. */
+  PropertyReference property;
+
+
+  PropertyExpression();
+
+  PropertyExpression.fromJson(core.Map _json) {
+    if (_json.containsKey("aggregationFunction")) {
+      aggregationFunction = _json["aggregationFunction"];
+    }
+    if (_json.containsKey("property")) {
+      property = new PropertyReference.fromJson(_json["property"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (aggregationFunction != null) {
+      _json["aggregationFunction"] = aggregationFunction;
+    }
+    if (property != null) {
+      _json["property"] = (property).toJson();
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class PropertyFilter {
+  /**
+   * The operator to filter by. One of lessThan, lessThanOrEqual, greaterThan,
+   * greaterThanOrEqual, equal, or hasAncestor.
+   * Possible string values are:
+   * - "EQUAL"
+   * - "GREATER_THAN"
+   * - "GREATER_THAN_OR_EQUAL"
+   * - "HAS_ANCESTOR"
+   * - "LESS_THAN"
+   * - "LESS_THAN_OR_EQUAL"
+   */
+  core.String operator;
+
+  /** The property to filter by. */
+  PropertyReference property;
+
+  /** The value to compare the property to. */
+  Value value;
+
+
+  PropertyFilter();
+
+  PropertyFilter.fromJson(core.Map _json) {
+    if (_json.containsKey("operator")) {
+      operator = _json["operator"];
+    }
+    if (_json.containsKey("property")) {
+      property = new PropertyReference.fromJson(_json["property"]);
+    }
+    if (_json.containsKey("value")) {
+      value = new Value.fromJson(_json["value"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (operator != null) {
+      _json["operator"] = operator;
+    }
+    if (property != null) {
+      _json["property"] = (property).toJson();
+    }
+    if (value != null) {
+      _json["value"] = (value).toJson();
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class PropertyOrder {
+  /**
+   * The direction to order by. One of ascending or descending. Optional,
+   * defaults to ascending.
+   * Possible string values are:
+   * - "ASCENDING"
+   * - "DESCENDING"
+   */
+  core.String direction;
+
+  /** The property to order by. */
+  PropertyReference property;
+
+
+  PropertyOrder();
+
+  PropertyOrder.fromJson(core.Map _json) {
+    if (_json.containsKey("direction")) {
+      direction = _json["direction"];
+    }
+    if (_json.containsKey("property")) {
+      property = new PropertyReference.fromJson(_json["property"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (direction != null) {
+      _json["direction"] = direction;
+    }
+    if (property != null) {
+      _json["property"] = (property).toJson();
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class PropertyReference {
+  /** The name of the property. */
+  core.String name;
+
+
+  PropertyReference();
+
+  PropertyReference.fromJson(core.Map _json) {
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (name != null) {
+      _json["name"] = name;
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class Query {
+  /**
+   * An ending point for the query results. Optional. Query cursors are returned
+   * in query result batches.
+   */
+  core.String endCursor;
+
+  core.List<core.int> get endCursorAsBytes {
+    return crypto.CryptoUtils.base64StringToBytes(endCursor);
+  }
+
+  void set endCursorAsBytes(core.List<core.int> _bytes) {
+    endCursor = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+  }
+
+  /** The filter to apply (optional). */
+  Filter filter;
+
+  /**
+   * The properties to group by (if empty, no grouping is applied to the result
+   * set).
+   */
+  core.List<PropertyReference> groupBy;
+
+  /** The kinds to query (if empty, returns entities from all kinds). */
+  core.List<KindExpression> kinds;
+
+  /**
+   * The maximum number of results to return. Applies after all other
+   * constraints. Optional.
+   */
+  core.int limit;
+
+  /**
+   * The number of results to skip. Applies before limit, but after all other
+   * constraints (optional, defaults to 0).
+   */
+  core.int offset;
+
+  /**
+   * The order to apply to the query results (if empty, order is unspecified).
+   */
+  core.List<PropertyOrder> order;
+
+  /** The projection to return. If not set the entire entity is returned. */
+  core.List<PropertyExpression> projection;
+
+  /**
+   * A starting point for the query results. Optional. Query cursors are
+   * returned in query result batches.
+   */
+  core.String startCursor;
+
+  core.List<core.int> get startCursorAsBytes {
+    return crypto.CryptoUtils.base64StringToBytes(startCursor);
+  }
+
+  void set startCursorAsBytes(core.List<core.int> _bytes) {
+    startCursor = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+  }
+
+
+  Query();
+
+  Query.fromJson(core.Map _json) {
+    if (_json.containsKey("endCursor")) {
+      endCursor = _json["endCursor"];
+    }
+    if (_json.containsKey("filter")) {
+      filter = new Filter.fromJson(_json["filter"]);
+    }
+    if (_json.containsKey("groupBy")) {
+      groupBy = _json["groupBy"].map((value) => new PropertyReference.fromJson(value)).toList();
+    }
+    if (_json.containsKey("kinds")) {
+      kinds = _json["kinds"].map((value) => new KindExpression.fromJson(value)).toList();
+    }
+    if (_json.containsKey("limit")) {
+      limit = _json["limit"];
+    }
+    if (_json.containsKey("offset")) {
+      offset = _json["offset"];
+    }
+    if (_json.containsKey("order")) {
+      order = _json["order"].map((value) => new PropertyOrder.fromJson(value)).toList();
+    }
+    if (_json.containsKey("projection")) {
+      projection = _json["projection"].map((value) => new PropertyExpression.fromJson(value)).toList();
+    }
+    if (_json.containsKey("startCursor")) {
+      startCursor = _json["startCursor"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (endCursor != null) {
+      _json["endCursor"] = endCursor;
+    }
+    if (filter != null) {
+      _json["filter"] = (filter).toJson();
+    }
+    if (groupBy != null) {
+      _json["groupBy"] = groupBy.map((value) => (value).toJson()).toList();
+    }
+    if (kinds != null) {
+      _json["kinds"] = kinds.map((value) => (value).toJson()).toList();
+    }
+    if (limit != null) {
+      _json["limit"] = limit;
+    }
+    if (offset != null) {
+      _json["offset"] = offset;
+    }
+    if (order != null) {
+      _json["order"] = order.map((value) => (value).toJson()).toList();
+    }
+    if (projection != null) {
+      _json["projection"] = projection.map((value) => (value).toJson()).toList();
+    }
+    if (startCursor != null) {
+      _json["startCursor"] = startCursor;
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class QueryResultBatch {
+  /**
+   * A cursor that points to the position after the last result in the batch.
+   * May be absent.
+   */
+  core.String endCursor;
+
+  core.List<core.int> get endCursorAsBytes {
+    return crypto.CryptoUtils.base64StringToBytes(endCursor);
+  }
+
+  void set endCursorAsBytes(core.List<core.int> _bytes) {
+    endCursor = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+  }
+
+  /**
+   * The result type for every entity in entityResults. full for full entities,
+   * projection for entities with only projected properties, keyOnly for
+   * entities with only a key.
+   * Possible string values are:
+   * - "FULL"
+   * - "KEY_ONLY"
+   * - "PROJECTION"
+   */
+  core.String entityResultType;
+
+  /** The results for this batch. */
+  core.List<EntityResult> entityResults;
+
+  /**
+   * The state of the query after the current batch. One of notFinished,
+   * moreResultsAfterLimit, noMoreResults.
+   * Possible string values are:
+   * - "MORE_RESULTS_AFTER_LIMIT"
+   * - "NOT_FINISHED"
+   * - "NO_MORE_RESULTS"
+   */
+  core.String moreResults;
+
+  /** The number of results skipped because of Query.offset. */
+  core.int skippedResults;
+
+
+  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("skippedResults")) {
+      skippedResults = _json["skippedResults"];
+    }
+  }
+
+  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 (skippedResults != null) {
+      _json["skippedResults"] = skippedResults;
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class ReadOptions {
+  /**
+   * The read consistency to use. One of default, strong, or eventual. Cannot be
+   * set when transaction is set. Lookup and ancestor queries default to strong,
+   * global queries default to eventual and cannot be set to strong. Optional.
+   * Default is default.
+   * Possible string values are:
+   * - "DEFAULT"
+   * - "EVENTUAL"
+   * - "STRONG"
+   */
+  core.String readConsistency;
+
+  /** The transaction to use. Optional. */
+  core.String transaction;
+
+  core.List<core.int> get transactionAsBytes {
+    return crypto.CryptoUtils.base64StringToBytes(transaction);
+  }
+
+  void set transactionAsBytes(core.List<core.int> _bytes) {
+    transaction = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+  }
+
+
+  ReadOptions();
+
+  ReadOptions.fromJson(core.Map _json) {
+    if (_json.containsKey("readConsistency")) {
+      readConsistency = _json["readConsistency"];
+    }
+    if (_json.containsKey("transaction")) {
+      transaction = _json["transaction"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (readConsistency != null) {
+      _json["readConsistency"] = readConsistency;
+    }
+    if (transaction != null) {
+      _json["transaction"] = transaction;
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class ResponseHeader {
+  /**
+   * Identifies what kind of resource this is. Value: the fixed string
+   * "datastore#responseHeader".
+   */
+  core.String kind;
+
+
+  ResponseHeader();
+
+  ResponseHeader.fromJson(core.Map _json) {
+    if (_json.containsKey("kind")) {
+      kind = _json["kind"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (kind != null) {
+      _json["kind"] = kind;
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class RollbackRequest {
+  /** The transaction identifier, returned by a call to beginTransaction. */
+  core.String transaction;
+
+  core.List<core.int> get transactionAsBytes {
+    return crypto.CryptoUtils.base64StringToBytes(transaction);
+  }
+
+  void set transactionAsBytes(core.List<core.int> _bytes) {
+    transaction = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+  }
+
+
+  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;
+  }
+}
+
+
+/** Not documented yet. */
+class RollbackResponse {
+  /** Not documented yet. */
+  ResponseHeader header;
+
+
+  RollbackResponse();
+
+  RollbackResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("header")) {
+      header = new ResponseHeader.fromJson(_json["header"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (header != null) {
+      _json["header"] = (header).toJson();
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class RunQueryRequest {
+  /**
+   * The GQL query to run. Either this field or field query must be set, but not
+   * both.
+   */
+  GqlQuery gqlQuery;
+
+  /**
+   * Entities are partitioned into subsets, identified by a dataset (usually
+   * implicitly specified by the project) and namespace ID. Queries are scoped
+   * to a single partition. This partition ID is normalized with the standard
+   * default context partition ID, but all other partition IDs in
+   * RunQueryRequest are normalized with this partition ID as the context
+   * partition ID.
+   */
+  PartitionId partitionId;
+
+  /**
+   * The query to run. Either this field or field gql_query must be set, but not
+   * both.
+   */
+  Query query;
+
+  /** The options for this query. */
+  ReadOptions readOptions;
+
+
+  RunQueryRequest();
+
+  RunQueryRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("gqlQuery")) {
+      gqlQuery = new GqlQuery.fromJson(_json["gqlQuery"]);
+    }
+    if (_json.containsKey("partitionId")) {
+      partitionId = new PartitionId.fromJson(_json["partitionId"]);
+    }
+    if (_json.containsKey("query")) {
+      query = new Query.fromJson(_json["query"]);
+    }
+    if (_json.containsKey("readOptions")) {
+      readOptions = new ReadOptions.fromJson(_json["readOptions"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (gqlQuery != null) {
+      _json["gqlQuery"] = (gqlQuery).toJson();
+    }
+    if (partitionId != null) {
+      _json["partitionId"] = (partitionId).toJson();
+    }
+    if (query != null) {
+      _json["query"] = (query).toJson();
+    }
+    if (readOptions != null) {
+      _json["readOptions"] = (readOptions).toJson();
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class RunQueryResponse {
+  /** A batch of query results (always present). */
+  QueryResultBatch batch;
+
+  /** Not documented yet. */
+  ResponseHeader header;
+
+
+  RunQueryResponse();
+
+  RunQueryResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("batch")) {
+      batch = new QueryResultBatch.fromJson(_json["batch"]);
+    }
+    if (_json.containsKey("header")) {
+      header = new ResponseHeader.fromJson(_json["header"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (batch != null) {
+      _json["batch"] = (batch).toJson();
+    }
+    if (header != null) {
+      _json["header"] = (header).toJson();
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class Value {
+  /** A blob key value. */
+  core.String blobKeyValue;
+
+  /** A blob value. May be a maximum of 1,000,000 bytes. */
+  core.String blobValue;
+
+  core.List<core.int> get blobValueAsBytes {
+    return crypto.CryptoUtils.base64StringToBytes(blobValue);
+  }
+
+  void set blobValueAsBytes(core.List<core.int> _bytes) {
+    blobValue = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+  }
+
+  /** A boolean value. */
+  core.bool booleanValue;
+
+  /** A timestamp value. */
+  core.DateTime dateTimeValue;
+
+  /** A double value. */
+  core.double doubleValue;
+
+  /**
+   * An entity value. May have no key. May have a key with an incomplete key
+   * path. May have a reserved/read-only key.
+   */
+  Entity entityValue;
+
+  /**
+   * If the value should be indexed.
+   *
+   * The indexed property may be set for a null value. When indexed is true,
+   * stringValue is limited to 500 characters and the blob value is limited to
+   * 500 bytes. Input values by default have indexed set to true; however, you
+   * can explicitly set indexed to true if you want. (An output value never has
+   * indexed explicitly set to true.) If a value is itself an entity, it cannot
+   * have indexed set to true.
+   */
+  core.bool indexed;
+
+  /** An integer value. */
+  core.String integerValue;
+
+  /** A key value. */
+  Key keyValue;
+
+  /**
+   * A list value. Cannot contain another list value. Cannot also have a meaning
+   * and indexing set.
+   */
+  core.List<Value> listValue;
+
+  /** The meaning field is reserved and should not be used. */
+  core.int meaning;
+
+  /** A UTF-8 encoded string value. */
+  core.String stringValue;
+
+
+  Value();
+
+  Value.fromJson(core.Map _json) {
+    if (_json.containsKey("blobKeyValue")) {
+      blobKeyValue = _json["blobKeyValue"];
+    }
+    if (_json.containsKey("blobValue")) {
+      blobValue = _json["blobValue"];
+    }
+    if (_json.containsKey("booleanValue")) {
+      booleanValue = _json["booleanValue"];
+    }
+    if (_json.containsKey("dateTimeValue")) {
+      dateTimeValue = core.DateTime.parse(_json["dateTimeValue"]);
+    }
+    if (_json.containsKey("doubleValue")) {
+      doubleValue = _json["doubleValue"];
+    }
+    if (_json.containsKey("entityValue")) {
+      entityValue = new Entity.fromJson(_json["entityValue"]);
+    }
+    if (_json.containsKey("indexed")) {
+      indexed = _json["indexed"];
+    }
+    if (_json.containsKey("integerValue")) {
+      integerValue = _json["integerValue"];
+    }
+    if (_json.containsKey("keyValue")) {
+      keyValue = new Key.fromJson(_json["keyValue"]);
+    }
+    if (_json.containsKey("listValue")) {
+      listValue = _json["listValue"].map((value) => new Value.fromJson(value)).toList();
+    }
+    if (_json.containsKey("meaning")) {
+      meaning = _json["meaning"];
+    }
+    if (_json.containsKey("stringValue")) {
+      stringValue = _json["stringValue"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (blobKeyValue != null) {
+      _json["blobKeyValue"] = blobKeyValue;
+    }
+    if (blobValue != null) {
+      _json["blobValue"] = blobValue;
+    }
+    if (booleanValue != null) {
+      _json["booleanValue"] = booleanValue;
+    }
+    if (dateTimeValue != null) {
+      _json["dateTimeValue"] = (dateTimeValue).toIso8601String();
+    }
+    if (doubleValue != null) {
+      _json["doubleValue"] = doubleValue;
+    }
+    if (entityValue != null) {
+      _json["entityValue"] = (entityValue).toJson();
+    }
+    if (indexed != null) {
+      _json["indexed"] = indexed;
+    }
+    if (integerValue != null) {
+      _json["integerValue"] = integerValue;
+    }
+    if (keyValue != null) {
+      _json["keyValue"] = (keyValue).toJson();
+    }
+    if (listValue != null) {
+      _json["listValue"] = listValue.map((value) => (value).toJson()).toList();
+    }
+    if (meaning != null) {
+      _json["meaning"] = meaning;
+    }
+    if (stringValue != null) {
+      _json["stringValue"] = stringValue;
+    }
+    return _json;
+  }
+}
+
+