Api-Roll 53: 2017-08-21

generated/googleapis/lib/servicemanagement/v1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.servicemanagement.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_1;
@@ skipping 78 matching lines @@
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Operation.fromJson(data));
   }
 
   /**
    * Lists service operations that match the specified filter in the request.
    *
    * Request parameters:
    *
+   * [pageSize] - The maximum number of operations to return. If unspecified,
+   * defaults to
+   * 50. The maximum value is 100.
+   *
    * [filter] - A string for filtering Operations.
    *   The following filter fields are supported:
    *
    *   * serviceName: Required. Only `=` operator is allowed.
    *   * startTime: The time this job was started, in ISO 8601 format.
    *     Allowed operators are `>=`,  `>`, `<=`, and `<`.
    *   * status&#58; Can be `done`, `in_progress`, or `failed`. Allowed
    *     operators are `=`, and `!=`.
    *
    *   Filter expression supports conjunction (AND) and disjunction (OR)
    *   logical operators. However, the serviceName restriction must be at the
    *   top-level and can only be combined with other restrictions via the AND
    *   logical operator.
    *
    *   Examples&#58;
    *
    *   * `serviceName={some-service}.googleapis.com`
    * * `serviceName={some-service}.googleapis.com AND startTime>="2017-02-01"`
    *   * `serviceName={some-service}.googleapis.com AND status=done`
    * * `serviceName={some-service}.googleapis.com AND (status=done OR
    * startTime>="2017-02-01")`
    *
    * [pageToken] - The standard list page token.
    *
    * [name] - Not used.
    *
-   * [pageSize] - The maximum number of operations to return. If unspecified,
-   * defaults to
-   * 50. The maximum value is 100.
-   *
    * Completes with a [ListOperationsResponse].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http_1.Client] completes with an error when making a REST
    * call, this method will complete with the same error.
    */
-  async.Future<ListOperationsResponse> list({core.String filter, core.String pageToken, core.String name, core.int pageSize}) {
+  async.Future<ListOperationsResponse> list({core.int pageSize, core.String filter, core.String pageToken, core.String name}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
     if (filter != null) {
       _queryParams["filter"] = [filter];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (name != null) {
       _queryParams["name"] = [name];
     }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
 
     _url = 'v1/operations';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 404 matching lines @@
    * Returns all public services. For authenticated users, also returns all
    * services the calling user has "servicemanagement.services.get" permission
    * for.
    *
    * **BETA:** If the caller specifies the `consumer_id`, it returns only the
    * services enabled on the consumer. The `consumer_id` must have the format
    * of "project:{PROJECT-ID}".
    *
    * Request parameters:
    *
+   * [pageSize] - Requested size of the next page of data.
+   *
+   * [producerProjectId] - Include services produced by the specified project.
+   *
    * [consumerId] - Include services consumed by the specified consumer.
    *
    * The Google Service Management implementation accepts the following
    * forms:
    * - project:<project_id>
    *
    * [pageToken] - Token identifying which result to start with; returned by a
    * previous list
    * call.
    *
-   * [pageSize] - Requested size of the next page of data.
-   *
-   * [producerProjectId] - Include services produced by the specified project.
-   *
    * Completes with a [ListServicesResponse].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http_1.Client] completes with an error when making a REST
    * call, this method will complete with the same error.
    */
-  async.Future<ListServicesResponse> list({core.String consumerId, core.String pageToken, core.int pageSize, core.String producerProjectId}) {
+  async.Future<ListServicesResponse> list({core.int pageSize, core.String producerProjectId, core.String consumerId, core.String pageToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
+    if (producerProjectId != null) {
+      _queryParams["producerProjectId"] = [producerProjectId];
+    }
     if (consumerId != null) {
       _queryParams["consumerId"] = [consumerId];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
-    if (producerProjectId != null) {
-      _queryParams["producerProjectId"] = [producerProjectId];
-    }
 
     _url = 'v1/services';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 725 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 (description != null) {
       _json["description"] = description;
     }
     return _json;
   }
 }
 
-/** Api is a light-weight descriptor for a protocol buffer service. */
+/**
+ * Api is a light-weight descriptor for an API Interface.
+ *
+ * Interfaces are also described as "protocol buffer services" in some contexts,
+ * such as by the "service" keyword in a .proto file, but they are different
+ * from API Services, which represent a concrete implementation of an interface
+ * as opposed to simply a description of methods and bindings. They are also
+ * sometimes simply referred to as "APIs" in other contexts, such as the name of
+ * this message itself. See https://cloud.google.com/apis/design/glossary for
+ * detailed terminology.
+ */
 class Api {
-  /** The methods of this api, in unspecified order. */
+  /** The methods of this interface, in unspecified order. */
   core.List<Method> methods;
-  /** Included APIs. See Mixin. */
+  /** Included interfaces. See Mixin. */
   core.List<Mixin> mixins;
   /**
-   * The fully qualified name of this api, including package name
-   * followed by the api's simple name.
+   * The fully qualified name of this interface, including package name
+   * followed by the interface's simple name.
    */
   core.String name;
-  /** Any metadata attached to the API. */
+  /** Any metadata attached to the interface. */
   core.List<Option> options;
   /**
    * Source context for the protocol buffer service represented by this
    * message.
    */
   SourceContext sourceContext;
   /**
    * The source syntax of the service.
    * Possible string values are:
    * - "SYNTAX_PROTO2" : Syntax `proto2`.
    * - "SYNTAX_PROTO3" : Syntax `proto3`.
    */
   core.String syntax;
   /**
-   * A version string for this api. If specified, must have the form
-   * `major-version.minor-version`, as in `1.10`. If the minor version
-   * is omitted, it defaults to zero. If the entire version field is
-   * empty, the major version is derived from the package name, as
-   * outlined below. If the field is not empty, the version in the
-   * package name will be verified to be consistent with what is
-   * provided here.
+   * A version string for this interface. If specified, must have the form
+   * `major-version.minor-version`, as in `1.10`. If the minor version is
+   * omitted, it defaults to zero. If the entire version field is empty, the
+   * major version is derived from the package name, as outlined below. If the
+   * field is not empty, the version in the package name will be verified to be
+   * consistent with what is provided here.
    *
    * The versioning schema uses [semantic
    * versioning](http://semver.org) where the major version number
    * indicates a breaking change and the minor version an additive,
    * non-breaking change. Both version numbers are signals to users
    * what to expect from different versions, and should be carefully
    * chosen based on the product plan.
    *
    * The major version is also reflected in the package name of the
-   * API, which must end in `v<major-version>`, as in
+   * interface, which must end in `v<major-version>`, as in
    * `google.feature.v1`. For major versions 0 and 1, the suffix can
    * be omitted. Zero major versions must only be used for
-   * experimental, none-GA apis.
+   * experimental, non-GA interfaces.
    */
   core.String version;
 
   Api();
 
   Api.fromJson(core.Map _json) {
     if (_json.containsKey("methods")) {
       methods = _json["methods"].map((value) => new Method.fromJson(value)).toList();
     }
     if (_json.containsKey("mixins")) {
@@ skipping 216 matching lines @@
    * LibraryService API will only accept JWTs with the following audience
    * "https://library-example.googleapis.com/google.example.library.v1.LibraryService".
    *
    * Example:
    *
    *     audiences: bookstore_android.apps.googleusercontent.com,
    *                bookstore_web.apps.googleusercontent.com
    */
   core.String audiences;
   /**
+   * Redirect URL if JWT token is required but no present or is expired.
+   * Implement authorizationUrl of securityDefinitions in OpenAPI spec.
+   */
+  core.String authorizationUrl;
+  /**
    * The unique identifier of the auth provider. It will be referred to by
    * `AuthRequirement.provider_id`.
    *
    * Example: "bookstore_auth".
    */
   core.String id;
   /**
    * Identifies the principal that issued the JWT. See
    * https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32#section-4.1.1
    * Usually a URL or an email address.
@@ skipping 17 matching lines @@
    * Example: https://www.googleapis.com/oauth2/v1/certs
    */
   core.String jwksUri;
 
   AuthProvider();
 
   AuthProvider.fromJson(core.Map _json) {
     if (_json.containsKey("audiences")) {
       audiences = _json["audiences"];
     }
+    if (_json.containsKey("authorizationUrl")) {
+      authorizationUrl = _json["authorizationUrl"];
+    }
     if (_json.containsKey("id")) {
       id = _json["id"];
     }
     if (_json.containsKey("issuer")) {
       issuer = _json["issuer"];
     }
     if (_json.containsKey("jwksUri")) {
       jwksUri = _json["jwksUri"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (audiences != null) {
       _json["audiences"] = audiences;
     }
+    if (authorizationUrl != null) {
+      _json["authorizationUrl"] = authorizationUrl;
+    }
     if (id != null) {
       _json["id"] = id;
     }
     if (issuer != null) {
       _json["issuer"] = issuer;
     }
     if (jwksUri != null) {
       _json["jwksUri"] = jwksUri;
     }
     return _json;
@@ skipping 399 matching lines @@
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (configChanges != null) {
       _json["configChanges"] = configChanges.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /** Write a Cloud Audit log */
 class CloudAuditOptions {
-  /** True if the log is for a permission of type DATA_READ or ADMIN_READ. */
-  core.bool isReadPermissionType;
   /**
    * 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("isReadPermissionType")) {
-      isReadPermissionType = _json["isReadPermissionType"];
-    }
     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 (isReadPermissionType != null) {
-      _json["isReadPermissionType"] = isReadPermissionType;
-    }
     if (logName != null) {
       _json["logName"] = logName;
     }
     return _json;
   }
 }
 
 /** A condition to be met. */
 class Condition {
   /**
@@ skipping 432 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 (environment != null) {
       _json["environment"] = environment;
     }
     return _json;
   }
 }
 
-/** Options for counters */
+/**
+ * Increment a streamz counter with the specified metric and field names.
+ *
+ * Metric names should start with a '/', generally be lowercase-only,
+ * and end in "_count". Field names should not contain an initial slash.
+ * The actual exported metric names will have "/iam/policy" prepended.
+ *
+ * Field names correspond to IAM request parameters and field values are
+ * their respective values.
+ *
+ * At present the only supported field names are
+ *    - "iam_principal", corresponding to IAMContext.principal;
+ *    - "" (empty string), resulting in one aggretated counter with no field.
+ *
+ * Examples:
+ *   counter { metric: "/debug_access_count"  field: "iam_principal" }
+ *   ==> increment counter /iam/policy/backend_debug_access_count
+ *                         {iam_principal=[value of IAMContext.principal]}
+ *
+ * At this time we do not support:
+ * * multiple field names (though this may be supported in the future)
+ * * decrementing the counter
+ * * incrementing it by anything other than 1
+ */
 class CounterOptions {
   /** The field value to attribute. */
   core.String field;
   /** The metric to update. */
   core.String metric;
 
   CounterOptions();
 
   CounterOptions.fromJson(core.Map _json) {
     if (_json.containsKey("field")) {
@@ skipping 151 matching lines @@
     }
     if (path != null) {
       _json["path"] = path;
     }
     return _json;
   }
 }
 
 /** Write a Data Access (Gin) log */
 class DataAccessOptions {
+  /**
+   * Whether Gin logging should happen in a fail-closed manner at the caller.
+   * This is relevant only in the LocalIAM implementation, for now.
+   * Possible string values are:
+   * - "LOG_MODE_UNSPECIFIED" : Client is not required to write a partial Gin
+   * log immediately after
+   * the authorization check. If client chooses to write one and it fails,
+   * client may either fail open (allow the operation to continue) or
+   * fail closed (handle as a DENY outcome).
+   * - "LOG_FAIL_CLOSED" : The application's operation in the context of which
+   * this authorization
+   * check is being made may only be performed if it is successfully logged
+   * to Gin. For instance, the authorization library may satisfy this
+   * obligation by emitting a partial log entry at authorization check time
+   * and only returning ALLOW to the application if it succeeds.
+   *
+   * If a matching Rule has this directive, but the client has not indicated
+   * that it will honor such requirements, then the IAM check will result in
+   * authorization failure by setting CheckPolicyResponse.success=false.
+   */
+  core.String logMode;
 
   DataAccessOptions();
 
   DataAccessOptions.fromJson(core.Map _json) {
+    if (_json.containsKey("logMode")) {
+      logMode = _json["logMode"];
+    }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (logMode != null) {
+      _json["logMode"] = logMode;
+    }
     return _json;
   }
 }
 
 /**
  * Strategy used to delete a service. This strategy is a placeholder only
  * used by the system generated rollout to delete a service.
  */
 class DeleteServiceStrategy {
 
@@ skipping 1231 matching lines @@
   core.String put;
   /**
    * The name of the response field whose value is mapped to the HTTP body of
    * response. Other response fields are ignored. This field is optional. When
    * not set, the response message will be used as HTTP body of response.
    * NOTE: the referred field must be not a repeated field and must be present
    * at the top-level of response message type.
    */
   core.String responseBody;
   /**
-   * Optional. The REST collection name is by default derived from the URL
-   * pattern. If specified, this field overrides the default collection name.
-   * Example:
-   *
-   *     rpc AddressesAggregatedList(AddressesAggregatedListRequest)
-   *         returns (AddressesAggregatedListResponse) {
-   *       option (google.api.http) = {
-   *         get: "/v1/projects/{project_id}/aggregated/addresses"
-   *         rest_collection: "projects.addresses"
-   *       };
-   *     }
-   *
-   * This method has the automatically derived collection name
-   * "projects.aggregated". Because, semantically, this rpc is actually an
-   * operation on the "projects.addresses" collection, the `rest_collection`
-   * field is configured to override the derived collection name.
-   */
-  core.String restCollection;
-  /**
-   * Optional. The rest method name is by default derived from the URL
-   * pattern. If specified, this field overrides the default method name.
-   * Example:
-   *
-   *     rpc CreateResource(CreateResourceRequest)
-   *         returns (CreateResourceResponse) {
-   *       option (google.api.http) = {
-   *         post: "/v1/resources",
-   *         body: "resource",
-   *         rest_method_name: "insert"
-   *       };
-   *     }
-   *
-   * This method has the automatically derived rest method name "create", but
-   *  for backwards compatability with apiary, it is specified as insert.
-   */
-  core.String restMethodName;
-  /**
    * Selects methods to which this rule applies.
    *
    * Refer to selector for syntax details.
    */
   core.String selector;
 
   HttpRule();
 
   HttpRule.fromJson(core.Map _json) {
     if (_json.containsKey("additionalBindings")) {
@@ skipping 22 matching lines @@
     }
     if (_json.containsKey("post")) {
       post = _json["post"];
     }
     if (_json.containsKey("put")) {
       put = _json["put"];
     }
     if (_json.containsKey("responseBody")) {
       responseBody = _json["responseBody"];
     }
-    if (_json.containsKey("restCollection")) {
-      restCollection = _json["restCollection"];
-    }
-    if (_json.containsKey("restMethodName")) {
-      restMethodName = _json["restMethodName"];
-    }
     if (_json.containsKey("selector")) {
       selector = _json["selector"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (additionalBindings != null) {
       _json["additionalBindings"] = additionalBindings.map((value) => (value).toJson()).toList();
     }
@@ skipping 20 matching lines @@
     }
     if (post != null) {
       _json["post"] = post;
     }
     if (put != null) {
       _json["put"] = put;
     }
     if (responseBody != null) {
       _json["responseBody"] = responseBody;
     }
-    if (restCollection != null) {
-      _json["restCollection"] = restCollection;
-    }
-    if (restMethodName != null) {
-      _json["restMethodName"] = restMethodName;
-    }
     if (selector != null) {
       _json["selector"] = selector;
     }
     return _json;
   }
 }
 
 /** A description of a label. */
 class LabelDescriptor {
   /** A human-readable description for the label. */
@@ skipping 153 matching lines @@
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     if (services != null) {
       _json["services"] = services.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
-/**
- * Specifies what kind of log the caller must write
- * Increment a streamz counter with the specified metric and field names.
- *
- * Metric names should start with a '/', generally be lowercase-only,
- * and end in "_count". Field names should not contain an initial slash.
- * The actual exported metric names will have "/iam/policy" prepended.
- *
- * Field names correspond to IAM request parameters and field values are
- * their respective values.
- *
- * At present the only supported field names are
- *    - "iam_principal", corresponding to IAMContext.principal;
- *    - "" (empty string), resulting in one aggretated counter with no field.
- *
- * Examples:
- *   counter { metric: "/debug_access_count"  field: "iam_principal" }
- *   ==> increment counter /iam/policy/backend_debug_access_count
- *                         {iam_principal=[value of IAMContext.principal]}
- *
- * At this time we do not support:
- * * multiple field names (though this may be supported in the future)
- * * decrementing the counter
- * * incrementing it by anything other than 1
- */
+/** Specifies what kind of log the caller must write */
 class LogConfig {
   /** Cloud audit options. */
   CloudAuditOptions cloudAudit;
   /** Counter options. */
   CounterOptions counter;
   /** Data access options. */
   DataAccessOptions dataAccess;
 
   LogConfig();
 
@@ skipping 413 matching lines @@
     if (startNotification != null) {
       _json["startNotification"] = startNotification;
     }
     if (uploadService != null) {
       _json["uploadService"] = uploadService;
     }
     return _json;
   }
 }
 
-/** Method represents a method of an api. */
+/** Method represents a method of an API interface. */
 class Method {
   /** The simple name of this method. */
   core.String name;
   /** Any metadata attached to the method. */
   core.List<Option> options;
   /** If true, the request is streamed. */
   core.bool requestStreaming;
   /** A URL of the input message type. */
   core.String requestTypeUrl;
   /** If true, the response is streamed. */
@@ skipping 300 matching lines @@
       _json["metricCosts"] = metricCosts;
     }
     if (selector != null) {
       _json["selector"] = selector;
     }
     return _json;
   }
 }
 
 /**
- * Declares an API to be included in this API. The including API must
- * redeclare all the methods from the included API, but documentation
- * and options are inherited as follows:
+ * Declares an API Interface to be included in this interface. The including
+ * interface must redeclare all the methods from the included interface, but
+ * documentation and options are inherited as follows:
  *
  * - If after comment and whitespace stripping, the documentation
  *   string of the redeclared method is empty, it will be inherited
  *   from the original method.
  *
  * - Each annotation belonging to the service config (http,
  *   visibility) which is not set in the redeclared method will be
  *   inherited.
  *
  * - If an http annotation is inherited, the path pattern will be
  *   modified as follows. Any version prefix will be replaced by the
- *   version of the including API plus the root path if specified.
+ *   version of the including interface plus the root path if
+ *   specified.
  *
  * Example of a simple mixin:
  *
  *     package google.acl.v1;
  *     service AccessControl {
  *       // Get the underlying ACL object.
  *       rpc GetAcl(GetAclRequest) returns (Acl) {
  *         option (google.api.http).get = "/v1/{resource=**}:getAcl";
  *       }
  *     }
@@ skipping 44 matching lines @@
  *
  *     service Storage {
  *       // Get the underlying ACL object.
  *       rpc GetAcl(GetAclRequest) returns (Acl) {
  *         option (google.api.http).get = "/v2/acls/{resource=**}:getAcl";
  *       }
  *       ...
  *     }
  */
 class Mixin {
-  /** The fully qualified name of the API which is included. */
+  /** The fully qualified name of the interface which is included. */
   core.String name;
   /**
    * If non-empty specifies a path under which inherited HTTP paths
    * are rooted.
    */
   core.String root;
 
   Mixin();
 
   Mixin.fromJson(core.Map _json) {
@@ skipping 1141 matching lines @@
    * author, as the remaining fields will be derived from the IDL during the
    * normalization process. It is an error to specify an API interface here
    * which cannot be resolved against the associated IDL files.
    */
   core.List<Api> apis;
   /** Auth configuration. */
   Authentication authentication;
   /** API backend configuration. */
   Backend backend;
   /**
-   * The version of the service configuration. The config version may
-   * influence interpretation of the configuration, for example, to
-   * determine defaults. This is documented together with applicable
-   * options. The current default for the config version itself is `3`.
+   * The semantic version of the service configuration. The config version
+   * affects the interpretation of the service configuration. For example,
+   * certain features are enabled by default for certain config versions.
+   * The latest config version is `3`.
    */
   core.int configVersion;
   /** Context configuration. */
   Context context;
   /** Configuration for the service control plane. */
   Control control;
   /** Custom error configuration. */
   CustomError customError;
   /** Additional API documentation. */
   Documentation documentation;
@@ skipping 1124 matching lines @@
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (restriction != null) {
       _json["restriction"] = restriction;
     }
     if (selector != null) {
       _json["selector"] = selector;
     }
     return _json;
   }
 }