Api-Roll 53: 2017-08-21

generated/googleapis/lib/serviceuser/v1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.serviceuser.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 263 matching lines @@
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new SearchServicesResponse.fromJson(data));
   }
 
 }
 
 
 
-/** 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 59 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 211 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 (provider != null) {
       _json["provider"] = provider;
     }
     return _json;
   }
 }
 
+/**
+ * Authorization rule for API services.
+ *
+ * It specifies the permission(s) required for an API element for the overall
+ * API request to succeed. It is typically used to mark request message fields
+ * that contain the name of the resource and indicates the permissions that
+ * will be checked on that resource.
+ *
+ * For example:
+ *
+ *     package google.storage.v1;
+ *
+ *     message CopyObjectRequest {
+ *       string source = 1 [
+ *         (google.api.authz).permissions = "storage.objects.get"];
+ *
+ *       string destination = 2 [
+ *         (google.api.authz).permissions =
+ *             "storage.objects.create,storage.objects.update"];
+ *     }
+ */
+class AuthorizationRule {
+  /**
+   * The required permissions. The acceptable values vary depend on the
+   * authorization system used. For Google APIs, it should be a comma-separated
+   * Google IAM permission values. When multiple permissions are listed, the
+   * semantics is not defined by the system. Additional documentation must
+   * be provided manually.
+   */
+  core.String permissions;
+  /**
+   * Selects the API elements to which this rule applies.
+   *
+   * Refer to selector for syntax details.
+   */
+  core.String selector;
+
+  AuthorizationRule();
+
+  AuthorizationRule.fromJson(core.Map _json) {
+    if (_json.containsKey("permissions")) {
+      permissions = _json["permissions"];
+    }
+    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 (permissions != null) {
+      _json["permissions"] = permissions;
+    }
+    if (selector != null) {
+      _json["selector"] = selector;
+    }
+    return _json;
+  }
+}
+
 /** `Backend` defines the backend configuration for a service. */
 class Backend {
   /**
    * A list of API backend rules that apply to individual API methods.
    *
    * **NOTE:** All service configuration rules follow "last one wins" order.
    */
   core.List<BackendRule> rules;
 
   Backend();
@@ skipping 1164 matching lines @@
  * repeated fields or map fields.
  */
 class HttpRule {
   /**
    * Additional HTTP bindings for the selector. Nested bindings must
    * not contain an `additional_bindings` field themselves (that is,
    * the nesting may only be one level deep).
    */
   core.List<HttpRule> additionalBindings;
   /**
+   * Specifies the permission(s) required for an API element for the overall
+   * API request to succeed. It is typically used to mark request message fields
+   * that contain the name of the resource and indicates the permissions that
+   * will be checked on that resource.
+   */
+  core.List<AuthorizationRule> authorizations;
+  /**
    * The name of the request field whose value is mapped to the HTTP body, or
    * `*` for mapping all fields not captured by the path pattern to the HTTP
    * body. NOTE: the referred field must not be a repeated field and must be
    * present at the top-level of request message type.
    */
   core.String body;
   /**
    * The custom pattern is used for specifying an HTTP method that is not
    * included in the `pattern` field, such as HEAD, or "*" to leave the
    * HTTP method unspecified for this rule. The wild-card rule is useful
@@ skipping 25 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;
   /**
+   * DO NOT USE. This is an experimental field.
+   *
    * 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;
   /**
+   * DO NOT USE. This is an experimental field.
+   *
    * 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.
+   * This method has the automatically derived rest method name
+   * "create", but for backwards compatibility 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")) {
       additionalBindings = _json["additionalBindings"].map((value) => new HttpRule.fromJson(value)).toList();
     }
+    if (_json.containsKey("authorizations")) {
+      authorizations = _json["authorizations"].map((value) => new AuthorizationRule.fromJson(value)).toList();
+    }
     if (_json.containsKey("body")) {
       body = _json["body"];
     }
     if (_json.containsKey("custom")) {
       custom = new CustomHttpPattern.fromJson(_json["custom"]);
     }
     if (_json.containsKey("delete")) {
       delete = _json["delete"];
     }
     if (_json.containsKey("get")) {
@@ skipping 26 matching lines @@
     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();
     }
+    if (authorizations != null) {
+      _json["authorizations"] = authorizations.map((value) => (value).toJson()).toList();
+    }
     if (body != null) {
       _json["body"] = body;
     }
     if (custom != null) {
       _json["custom"] = (custom).toJson();
     }
     if (delete != null) {
       _json["delete"] = delete;
     }
     if (get != null) {
@@ skipping 460 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 884 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 896 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;
   }
 }