Api-Roll 51: 2017-07-10

generated/googleapis/lib/spanner/v1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.spanner.v1;
 
 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;
 
 export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show
     ApiRequestError, DetailedApiRequestError;
 
 const core.String USER_AGENT = 'dart-api-client spanner/v1';
 
 /**
  * Cloud Spanner is a managed, mission-critical, globally consistent and
  * scalable relational database service.
  */
 class SpannerApi {
   /** View and manage your data across Google Cloud Platform services */
   static const CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform";
 
+  /** Administer your Spanner databases */
+  static const SpannerAdminScope = "https://www.googleapis.com/auth/spanner.admin";
+
+  /** View and manage the contents of your Spanner databases */
+  static const SpannerDataScope = "https://www.googleapis.com/auth/spanner.data";
+
 
   final commons.ApiRequester _requester;
 
   ProjectsResourceApi get projects => new ProjectsResourceApi(_requester);
 
   SpannerApi(http.Client client, {core.String rootUrl: "https://spanner.googleapis.com/", core.String servicePath: ""}) :
       _requester = new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
 }
 
 
@@ skipping 1220 matching lines @@
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Operation.fromJson(data));
   }
 
   /**
    * Lists operations that match the specified filter in the request. If the
    * server doesn't support this method, it returns `UNIMPLEMENTED`.
    *
-   * NOTE: the `name` binding below allows API services to override the binding
-   * to use different resource name schemes, such as `users / * /operations`.
+   * NOTE: the `name` binding allows API services to override the binding
+   * to use different resource name schemes, such as `users / * /operations`. To
+   * override the binding, API services can add a binding such as
+   * `"/v1/{name=users / * }/operations"` to their service configuration.
+   * For backwards compatibility, the default name includes the operations
+   * collection id, however overriding users must ensure the name binding
+   * is the parent resource, without the operations collection id.
    *
    * Request parameters:
    *
-   * [name] - The name of the operation collection.
+   * [name] - The name of the operation's parent resource.
    * Value must have pattern
    * "^projects/[^/]+/instances/[^/]+/databases/[^/]+/operations$".
    *
-   * [filter] - The standard list filter.
-   *
    * [pageToken] - The standard list page token.
    *
    * [pageSize] - The standard list page size.
    *
+   * [filter] - The standard list filter.
+   *
    * Completes with a [ListOperationsResponse].
    *
    * 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<ListOperationsResponse> list(core.String name, {core.String filter, core.String pageToken, core.int pageSize}) {
+  async.Future<ListOperationsResponse> list(core.String name, {core.String pageToken, core.int pageSize, core.String filter}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
-    if (filter != null) {
-      _queryParams["filter"] = [filter];
-    }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
+    if (filter != null) {
+      _queryParams["filter"] = [filter];
+    }
 
     _url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 667 matching lines @@
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Operation.fromJson(data));
   }
 
   /**
    * Lists operations that match the specified filter in the request. If the
    * server doesn't support this method, it returns `UNIMPLEMENTED`.
    *
-   * NOTE: the `name` binding below allows API services to override the binding
-   * to use different resource name schemes, such as `users / * /operations`.
+   * NOTE: the `name` binding allows API services to override the binding
+   * to use different resource name schemes, such as `users / * /operations`. To
+   * override the binding, API services can add a binding such as
+   * `"/v1/{name=users / * }/operations"` to their service configuration.
+   * For backwards compatibility, the default name includes the operations
+   * collection id, however overriding users must ensure the name binding
+   * is the parent resource, without the operations collection id.
    *
    * Request parameters:
    *
-   * [name] - The name of the operation collection.
+   * [name] - The name of the operation's parent resource.
    * Value must have pattern "^projects/[^/]+/instances/[^/]+/operations$".
    *
-   * [pageSize] - The standard list page size.
-   *
    * [filter] - The standard list filter.
    *
    * [pageToken] - The standard list page token.
    *
+   * [pageSize] - The standard list page size.
+   *
    * Completes with a [ListOperationsResponse].
    *
    * 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<ListOperationsResponse> list(core.String name, {core.int pageSize, core.String filter, core.String pageToken}) {
+  async.Future<ListOperationsResponse> list(core.String name, {core.String filter, core.String pageToken, core.int pageSize}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
     if (filter != null) {
       _queryParams["filter"] = [filter];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
 
     _url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 179 matching lines @@
     if (options != null) {
       _json["options"] = (options).toJson();
     }
     return _json;
   }
 }
 
 /** Associates `members` with a `role`. */
 class Binding {
   /**
+   * The condition that is associated with this binding.
+   * NOTE: an unsatisfied condition will not allow user access via current
+   * binding. Different bindings, including their conditions, are examined
+   * independently.
+   * This field is GOOGLE_INTERNAL.
+   */
+  Expr condition;
+  /**
    * Specifies the identities requesting access for a Cloud Platform resource.
    * `members` can have the following values:
    *
    * * `allUsers`: A special identifier that represents anyone who is
    *    on the internet; with or without a Google account.
    *
    * * `allAuthenticatedUsers`: A special identifier that represents anyone
    *    who is authenticated with a Google account or a service account.
    *
    * * `user:{emailid}`: An email address that represents a specific Google
    *    account. For example, `alice@gmail.com` or `joe@example.com`.
    *
    *
    * * `serviceAccount:{emailid}`: An email address that represents a service
    *    account. For example, `my-other-app@appspot.gserviceaccount.com`.
    *
    * * `group:{emailid}`: An email address that represents a Google group.
    *    For example, `admins@example.com`.
    *
+   *
    * * `domain:{domain}`: A Google Apps domain name that represents all the
    *    users of that domain. For example, `google.com` or `example.com`.
    */
   core.List<core.String> members;
   /**
    * Role that is assigned to `members`.
    * For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
    * Required
    */
   core.String role;
 
   Binding();
 
   Binding.fromJson(core.Map _json) {
+    if (_json.containsKey("condition")) {
+      condition = new Expr.fromJson(_json["condition"]);
+    }
     if (_json.containsKey("members")) {
       members = _json["members"];
     }
     if (_json.containsKey("role")) {
       role = _json["role"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (condition != null) {
+      _json["condition"] = (condition).toJson();
+    }
     if (members != null) {
       _json["members"] = members;
     }
     if (role != null) {
       _json["role"] = role;
     }
     return _json;
   }
 }
 
@@ skipping 47 matching lines @@
     }
     if (variable != null) {
       _json["variable"] = variable;
     }
     return _json;
   }
 }
 
 /** Write a Cloud Audit log */
 class CloudAuditOptions {
+  /**
+   * The log_name to populate in the Cloud Audit Record.
+   * Possible string values are:
+   * - "UNSPECIFIED_LOG_NAME" : Default. Should not be used.
+   * - "ADMIN_ACTIVITY" : Corresponds to "cloudaudit.googleapis.com/activity"
+   * - "DATA_ACCESS" : Corresponds to "cloudaudit.googleapis.com/data_access"
+   */
+  core.String logName;
 
   CloudAuditOptions();
 
   CloudAuditOptions.fromJson(core.Map _json) {
+    if (_json.containsKey("logName")) {
+      logName = _json["logName"];
+    }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (logName != null) {
+      _json["logName"] = logName;
+    }
     return _json;
   }
 }
 
 /** The request for Commit. */
 class CommitRequest {
   /**
    * The mutations to be executed when this transaction commits. All
    * mutations are applied atomically, in the order they appear in
    * this list.
@@ skipping 90 matching lines @@
    * the *absence* of a realm, so realm conditions can only be used in
    * a "positive" context (e.g., ALLOW/IN or DENY/NOT_IN).
    * - "APPROVER" : An approver (distinct from the requester) that has
    * authorized this
    * request.
    * When used with IN, the condition indicates that one of the approvers
    * associated with the request matches the specified principal, or is a
    * member of the specified group. Approvers can only grant additional
    * access, and are thus only used in a strictly positive context
    * (e.g. ALLOW/IN or DENY/NOT_IN).
-   * See: go/rpc-security-policy-dynamicauth.
    * - "JUSTIFICATION_TYPE" : What types of justifications have been supplied
    * with this request.
    * String values should match enum names from tech.iam.JustificationType,
    * e.g. "MANUAL_STRING". It is not permitted to grant access based on
    * the *absence* of a justification, so justification conditions can only
    * be used in a "positive" context (e.g., ALLOW/IN or DENY/NOT_IN).
    *
    * Multiple justifications, e.g., a Buganizer ID and a manually-entered
    * reason, are normal and supported.
    */
@@ skipping 495 matching lines @@
     if (sql != null) {
       _json["sql"] = sql;
     }
     if (transaction != null) {
       _json["transaction"] = (transaction).toJson();
     }
     return _json;
   }
 }
 
+/**
+ * Represents an expression text. Example:
+ *
+ *     title: "User account presence"
+ *     description: "Determines whether the request has a user account"
+ *     expression: "size(request.user) > 0"
+ */
+class Expr {
+  /**
+   * An optional description of the expression. This is a longer text which
+   * describes the expression, e.g. when hovered over it in a UI.
+   */
+  core.String description;
+  /**
+   * Textual representation of an expression in
+   * [Common Expression Language](http://go/api-expr) syntax.
+   *
+   * The application context of the containing message determines which
+   * well-known feature set of CEL is supported.
+   */
+  core.String expression;
+  /**
+   * An optional string indicating the location of the expression for error
+   * reporting, e.g. a file name and a position in the file.
+   */
+  core.String location;
+  /**
+   * An optional title for the expression, i.e. a short string describing
+   * its purpose. This can be used e.g. in UIs which allow to enter the
+   * expression.
+   */
+  core.String title;
+
+  Expr();
+
+  Expr.fromJson(core.Map _json) {
+    if (_json.containsKey("description")) {
+      description = _json["description"];
+    }
+    if (_json.containsKey("expression")) {
+      expression = _json["expression"];
+    }
+    if (_json.containsKey("location")) {
+      location = _json["location"];
+    }
+    if (_json.containsKey("title")) {
+      title = _json["title"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (description != null) {
+      _json["description"] = description;
+    }
+    if (expression != null) {
+      _json["expression"] = expression;
+    }
+    if (location != null) {
+      _json["location"] = location;
+    }
+    if (title != null) {
+      _json["title"] = title;
+    }
+    return _json;
+  }
+}
+
 /** Message representing a single field of a struct. */
 class Field {
   /**
    * The name of the field. For reads, this is the column name. For
    * SQL queries, it is the column alias (e.g., `"Word"` in the
    * query `"SELECT 'hello' AS Word"`), or the column name (e.g.,
    * `"ColName"` in the query `"SELECT ColName FROM Table"`). Some
    * columns might have an empty name (e.g., !"SELECT
    * UPPER(ColName)"`). Note that a query result can contain
    * multiple fields with the same name.
@@ skipping 1063 matching lines @@
  *     }
  *
  * For a description of IAM and its features, see the
  * [IAM developer's guide](https://cloud.google.com/iam).
  */
 class Policy {
   /** Specifies cloud audit logging configuration for this policy. */
   core.List<AuditConfig> auditConfigs;
   /**
    * Associates a list of `members` to a `role`.
-   * Multiple `bindings` must not be specified for the same `role`.
    * `bindings` with no members will result in an error.
    */
   core.List<Binding> bindings;
   /**
    * `etag` is used for optimistic concurrency control as a way to help
    * prevent simultaneous updates of a policy from overwriting each other.
    * It is strongly suggested that systems make use of the `etag` in the
    * read-modify-write cycle to perform policy updates in order to avoid race
    * conditions: An `etag` is returned in the response to `getIamPolicy`, and
    * systems are expected to put that etag in the request to `setIamPolicy` to
@@ skipping 92 matching lines @@
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (planNodes != null) {
       _json["planNodes"] = planNodes.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
-/** Options for read-only transactions. */
+/** Message type to initiate a read-only transaction. */
 class ReadOnly {
   /**
    * Executes all reads at a timestamp that is `exact_staleness`
    * old. The timestamp is chosen soon after the read is started.
    *
    * Guarantees that all writes that have committed more than the
    * specified number of seconds ago are visible. Because Cloud Spanner
    * chooses the exact timestamp, this mode works even if the client's
    * local clock is substantially skewed from Cloud Spanner commit
    * timestamps.
@@ skipping 202 matching lines @@
     if (table != null) {
       _json["table"] = table;
     }
     if (transaction != null) {
       _json["transaction"] = (transaction).toJson();
     }
     return _json;
   }
 }
 
-/** Options for read-write transactions. */
+/**
+ * Message type to initiate a read-write transaction. Currently this
+ * transaction type has no options.
+ */
 class ReadWrite {
 
   ReadWrite();
 
   ReadWrite.fromJson(core.Map _json) {
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     return _json;
@@ skipping 382 matching lines @@
  *
  * The `Status` message contains three pieces of data: error code, error
  * message,
  * and error details. The error code should be an enum value of
  * google.rpc.Code, but it may accept additional error codes if needed.  The
  * error message should be a developer-facing English message that helps
  * developers *understand* and *resolve* the error. If a localized user-facing
  * error message is needed, put the localized message in the error details or
  * localize it in the client. The optional error details may contain arbitrary
  * information about the error. There is a predefined set of error detail types
- * in the package `google.rpc` which can be used for common error conditions.
+ * in the package `google.rpc` that can be used for common error conditions.
  *
  * # Language mapping
  *
  * The `Status` message is the logical representation of the error model, but it
  * is not necessarily the actual wire format. When the `Status` message is
  * exposed in different client libraries and different wire protocols, it can be
  * mapped differently. For example, it will likely be mapped to some exceptions
  * in Java, but more likely mapped to some error codes in C.
  *
  * # Other uses
  *
  * The error model and the `Status` message can be used in a variety of
  * environments, either with or without APIs, to provide a
  * consistent developer experience across different environments.
  *
  * Example uses of this error model include:
  *
  * - Partial errors. If a service needs to return partial errors to the client,
  *     it may embed the `Status` in the normal response to indicate the partial
  *     errors.
  *
  * - Workflow errors. A typical workflow has multiple steps. Each step may
- *     have a `Status` message for error reporting purpose.
+ *     have a `Status` message for error reporting.
  *
  * - Batch operations. If a client uses batch request and batch response, the
  *     `Status` message should be used directly inside batch response, one for
  *     each error sub-response.
  *
  * - Asynchronous operations. If an API call embeds asynchronous operation
  *     results in its response, the status of those operations should be
  *     represented directly using the `Status` message.
  *
  * - Logging. If some API errors are stored in logs, the message `Status` could
@@ skipping 827 matching lines @@
     }
     if (table != null) {
       _json["table"] = table;
     }
     if (values != null) {
       _json["values"] = values;
     }
     return _json;
   }
 }