Roll of googleapis as of 4/7/2015.

generated/googleapis_beta/lib/datastore/v1beta2.dart

+// This is a generated file (see the discoveryapis_generator project).
+
 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 '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:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
+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;
+export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show
+    ApiRequestError, DetailedApiRequestError;
+
+const core.String USER_AGENT = 'dart-api-client datastore/v1beta2';
 
 /** API for accessing Google Cloud Datastore. */
 class DatastoreApi {
   /** View and manage your data across Google Cloud Platform services */
   static const CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform";
 
   /** 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;
+  final commons.ApiRequester _requester;
 
   DatasetsResourceApi get datasets => new DatasetsResourceApi(_requester);
 
   DatastoreApi(http.Client client, {core.String rootUrl: "https://www.googleapis.com/", core.String servicePath: "datastore/v1beta2/datasets/"}) :
-      _requester = new common_internal.ApiRequester(client, rootUrl, servicePath);
+      _requester = new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
 }
 
 
-/** Not documented yet. */
 class DatasetsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  DatasetsResourceApi(common_internal.ApiRequester client) : 
+  DatasetsResourceApi(commons.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
+   * Completes with a [commons.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 _downloadOptions = commons.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';
+    _url = commons.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
+   * Completes with a [commons.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 _downloadOptions = commons.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';
+    _url = commons.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
+   * Completes with a [commons.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 _downloadOptions = commons.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';
+    _url = commons.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
+   * Completes with a [commons.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 _downloadOptions = commons.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';
+    _url = commons.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
+   * Completes with a [commons.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 _downloadOptions = commons.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';
+    _url = commons.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
+   * Completes with a [commons.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 _downloadOptions = commons.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';
+    _url = commons.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();
@@ skipping 13 matching lines @@
       _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"
@@ skipping 13 matching lines @@
   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) {
@@ skipping 18 matching lines @@
       _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;
 
@@ skipping 44 matching lines @@
       _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")) {
@@ skipping 72 matching lines @@
   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));
+      properties = commons.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());
+      _json["properties"] = commons.mapMap(properties, (item) => (item).toJson());
     }
     return _json;
   }
 }
 
 
 /** The result of fetching an entity from the datastore. */
 class EntityResult {
   /** The resulting entity. */
   Entity entity;
@@ skipping 107 matching lines @@
     if (queryString != null) {
       _json["queryString"] = queryString;
     }
     return _json;
   }
 }
 
 
 /** A binding argument for a GQL query. */
 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")) {
@@ skipping 144 matching lines @@
   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();
 
@@ skipping 12 matching lines @@
       _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")) {
@@ skipping 106 matching lines @@
       _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;
 
@@ skipping 571 matching lines @@
       _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"
@@ skipping 29 matching lines @@
       _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);
@@ skipping 11 matching lines @@
   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
@@ skipping 43 matching lines @@
       _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")) {
@@ skipping 154 matching lines @@
     }
     if (meaning != null) {
       _json["meaning"] = meaning;
     }
     if (stringValue != null) {
       _json["stringValue"] = stringValue;
     }
     return _json;
   }
 }
-
-