Api-roll 42: 2016-11-08

generated/googleapis/lib/dataproc/v1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.dataproc.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 dataproc/v1';
 
-/** Manages Hadoop-based clusters and jobs on Google Cloud Platform. */
+/**
+ * An API for managing Hadoop-based clusters and jobs on Google Cloud Platform.
+ */
 class DataprocApi {
   /** View and manage your data across Google Cloud Platform services */
   static const CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform";
 
 
   final commons.ApiRequester _requester;
 
   ProjectsResourceApi get projects => new ProjectsResourceApi(_requester);
 
   DataprocApi(http.Client client, {core.String rootUrl: "https://dataproc.googleapis.com/", core.String servicePath: ""}) :
@@ skipping 243 matching lines @@
    * Lists all regions/{region}/clusters in a project.
    *
    * Request parameters:
    *
    * [projectId] - [Required] The ID of the Google Cloud Platform project that
    * the cluster belongs to.
    *
    * [region] - [Required] The Cloud Dataproc region in which to handle the
    * request.
    *
-   * [pageSize] - The standard List page size.
+   * [filter] - [Optional] A filter constraining the clusters to list. Filters
+   * are case-sensitive and have the following syntax: field:value [field:value]
+   * ... or field = value [AND [field = value]] ... where **field** is one of
+   * `status.state`, `clusterName`, or `labels.[KEY]`, and `[KEY]` is a label
+   * key. **value** can be `*` to match all values. `status.state` can be one of
+   * the following: `ACTIVE`, `INACTIVE`, `CREATING`, `RUNNING`, `ERROR`,
+   * `DELETING`, or `UPDATING`. `ACTIVE` contains the `CREATING`, `UPDATING`,
+   * and `RUNNING` states. `INACTIVE` contains the `DELETING` and `ERROR`
+   * states. `clusterName` is the name of the cluster provided at creation time.
+   * Only the logical `AND` operator is supported; space-separated items are
+   * treated as having an implicit `AND` operator. Example valid filters are:
+   * status.state:ACTIVE clusterName:mycluster labels.env:staging \
+   * labels.starred:* and status.state = ACTIVE AND clusterName = mycluster \
+   * AND labels.env = staging AND labels.starred = *
    *
-   * [pageToken] - The standard List page token.
+   * [pageSize] - [Optional] The standard List page size.
+   *
+   * [pageToken] - [Optional] The standard List page token.
    *
    * Completes with a [ListClustersResponse].
    *
    * 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<ListClustersResponse> list(core.String projectId, core.String region, {core.int pageSize, core.String pageToken}) {
+  async.Future<ListClustersResponse> list(core.String projectId, core.String region, {core.String filter, core.int pageSize, 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 (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (region == null) {
       throw new core.ArgumentError("Parameter region is required.");
     }
+    if (filter != null) {
+      _queryParams["filter"] = [filter];
+    }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
     _url = 'v1/projects/' + commons.Escaper.ecapeVariable('$projectId') + '/regions/' + commons.Escaper.ecapeVariable('$region') + '/clusters';
 
     var _response = _requester.request(_url,
@@ skipping 264 matching lines @@
    *
    * [pageSize] - [Optional] The number of results to return in each response.
    *
    * [pageToken] - [Optional] The page token, returned by a previous call, to
    * request the next page of results.
    *
    * [clusterName] - [Optional] If set, the returned jobs list includes only
    * jobs that were submitted to the named cluster.
    *
    * [jobStateMatcher] - [Optional] Specifies enumerated categories of jobs to
-   * list.
+   * list (default = match ALL jobs).
    * Possible string values are:
    * - "ALL" : A ALL.
    * - "ACTIVE" : A ACTIVE.
    * - "NON_ACTIVE" : A NON_ACTIVE.
    *
+   * [filter] - [Optional] A filter constraining the jobs to list. Filters are
+   * case-sensitive and have the following syntax: field:value] ... or [field =
+   * value] AND [field [= value]] ... where **field** is `status.state` or
+   * `labels.[KEY]`, and `[KEY]` is a label key. **value** can be `*` to match
+   * all values. `status.state` can be either `ACTIVE` or `INACTIVE`. Only the
+   * logical `AND` operator is supported; space-separated items are treated as
+   * having an implicit `AND` operator. Example valid filters are:
+   * status.state:ACTIVE labels.env:staging labels.starred:* and status.state =
+   * ACTIVE AND labels.env = staging AND labels.starred = *
+   *
    * Completes with a [ListJobsResponse].
    *
    * 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<ListJobsResponse> list(core.String projectId, core.String region, {core.int pageSize, core.String pageToken, core.String clusterName, core.String jobStateMatcher}) {
+  async.Future<ListJobsResponse> list(core.String projectId, core.String region, {core.int pageSize, core.String pageToken, core.String clusterName, core.String jobStateMatcher, 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 (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (region == null) {
       throw new core.ArgumentError("Parameter region is required.");
     }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (clusterName != null) {
       _queryParams["clusterName"] = [clusterName];
     }
     if (jobStateMatcher != null) {
       _queryParams["jobStateMatcher"] = [jobStateMatcher];
     }
+    if (filter != null) {
+      _queryParams["filter"] = [filter];
+    }
 
     _url = 'v1/projects/' + commons.Escaper.ecapeVariable('$projectId') + '/regions/' + commons.Escaper.ecapeVariable('$region') + '/jobs';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 59 matching lines @@
 
   ProjectsRegionsOperationsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Starts asynchronous cancellation on a long-running operation. The server
    * makes a best effort to cancel the operation, but success is not guaranteed.
    * If the server doesn't support this method, it returns
    * `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or
    * other methods to check whether the cancellation succeeded or whether the
-   * operation completed despite cancellation.
+   * operation completed despite cancellation. On successful cancellation, the
+   * operation is not deleted; instead, it becomes an operation with an
+   * Operation.error value with a google.rpc.Status.code of 1, corresponding to
+   * `Code.CANCELLED`.
    *
    * Request parameters:
    *
    * [name] - The name of the operation resource to be cancelled.
-   * Value must have pattern "^projects/[^/] * / regions/[^/] * /
-   * operations/[^/]*$".
+   * Value must have pattern "^projects/[^/]+/regions/[^/]+/operations/[^/]+$".
    *
    * Completes with a [Empty].
    *
    * 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<Empty> cancel(core.String name) {
@@ skipping 22 matching lines @@
 
   /**
    * Deletes a long-running operation. This method indicates that the client is
    * no longer interested in the operation result. It does not cancel the
    * operation. If the server doesn't support this method, it returns
    * `google.rpc.Code.UNIMPLEMENTED`.
    *
    * Request parameters:
    *
    * [name] - The name of the operation resource to be deleted.
-   * Value must have pattern "^projects/[^/] * / regions/[^/] * /
-   * operations/[^/]*$".
+   * Value must have pattern "^projects/[^/]+/regions/[^/]+/operations/[^/]+$".
    *
    * Completes with a [Empty].
    *
    * 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<Empty> delete(core.String name) {
@@ skipping 21 matching lines @@
   }
 
   /**
    * Gets the latest state of a long-running operation. Clients can use this
    * method to poll the operation result at intervals as recommended by the API
    * service.
    *
    * Request parameters:
    *
    * [name] - The name of the operation resource.
-   * Value must have pattern "^projects/[^/] * / regions/[^/] * /
-   * operations/[^/]*$".
+   * Value must have pattern "^projects/[^/]+/regions/[^/]+/operations/[^/]+$".
    *
    * Completes with a [Operation].
    *
    * 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<Operation> get(core.String name) {
@@ skipping 22 matching lines @@
 
   /**
    * 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`.
    *
    * Request parameters:
    *
    * [name] - The name of the operation collection.
-   * Value must have pattern "^projects/[^/] * / regions/[^/] * / operations$".
+   * Value must have pattern "^projects/[^/]+/regions/[^/]+/operations$".
    *
    * [filter] - The standard list filter.
    *
    * [pageSize] - The standard list page size.
    *
    * [pageToken] - The standard list page token.
    *
    * Completes with a [ListOperationsResponse].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
@@ skipping 67 matching lines @@
    * [Output-only] A cluster UUID (Unique Universal Identifier). Cloud Dataproc
    * generates this value when it creates the cluster.
    */
   core.String clusterUuid;
   /**
    * [Required] The cluster config. Note that Cloud Dataproc may set default
    * values, and values may change when clusters are updated.
    */
   ClusterConfig config;
   /**
+   * [Optional] The labels to associate with this cluster. Label **keys** must
+   * contain 1 to 63 characters, and must conform to [RFC
+   * 1035](https://www.ietf.org/rfc/rfc1035.txt). Label **values** may be empty,
+   * but, if present, must contain 1 to 63 characters, and must conform to [RFC
+   * 1035](https://www.ietf.org/rfc/rfc1035.txt). No more than 32 labels can be
+   * associated with a cluster.
+   */
+  core.Map<core.String, core.String> labels;
+  /**
+   * Contains cluster daemon metrics such as HDFS and YARN stats. **Beta
+   * Feature**: This report is available for testing purposes only. It may be
+   * changed before final release.
+   */
+  ClusterMetrics metrics;
+  /**
    * [Required] The Google Cloud Platform project ID that the cluster belongs
    * to.
    */
   core.String projectId;
   /** [Output-only] Cluster status. */
   ClusterStatus status;
   /** [Output-only] The previous cluster status. */
   core.List<ClusterStatus> statusHistory;
 
   Cluster();
 
   Cluster.fromJson(core.Map _json) {
     if (_json.containsKey("clusterName")) {
       clusterName = _json["clusterName"];
     }
     if (_json.containsKey("clusterUuid")) {
       clusterUuid = _json["clusterUuid"];
     }
     if (_json.containsKey("config")) {
       config = new ClusterConfig.fromJson(_json["config"]);
     }
+    if (_json.containsKey("labels")) {
+      labels = _json["labels"];
+    }
+    if (_json.containsKey("metrics")) {
+      metrics = new ClusterMetrics.fromJson(_json["metrics"]);
+    }
     if (_json.containsKey("projectId")) {
       projectId = _json["projectId"];
     }
     if (_json.containsKey("status")) {
       status = new ClusterStatus.fromJson(_json["status"]);
     }
     if (_json.containsKey("statusHistory")) {
       statusHistory = _json["statusHistory"].map((value) => new ClusterStatus.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (clusterName != null) {
       _json["clusterName"] = clusterName;
     }
     if (clusterUuid != null) {
       _json["clusterUuid"] = clusterUuid;
     }
     if (config != null) {
       _json["config"] = (config).toJson();
     }
+    if (labels != null) {
+      _json["labels"] = labels;
+    }
+    if (metrics != null) {
+      _json["metrics"] = (metrics).toJson();
+    }
     if (projectId != null) {
       _json["projectId"] = projectId;
     }
     if (status != null) {
       _json["status"] = (status).toJson();
     }
     if (statusHistory != null) {
       _json["statusHistory"] = statusHistory.map((value) => (value).toJson()).toList();
     }
     return _json;
@@ skipping 13 matching lines @@
   core.String configBucket;
   /**
    * [Required] The shared Google Compute Engine config settings for all
    * instances in a cluster.
    */
   GceClusterConfig gceClusterConfig;
   /**
    * [Optional] Commands to execute on each node after config is completed. By
    * default, executables are run on master and all worker nodes. You can test a
    * node's role metadata to run an executable on a master or worker node, as
-   * shown below: ROLE=$(/usr/share/google/get_metadata_value attributes/role)
-   * if [[ "${ROLE}" == 'Master' ]]; then ... master specific actions ... else
-   * ... worker specific actions ... fi
+   * shown below using `curl` (you can also use `wget`): ROLE=$(curl -H
+   * Metadata-Flavor:Google
+   * http://metadata/computeMetadata/v1/instance/attributes/dataproc-role) if [[
+   * "${ROLE}" == 'Master' ]]; then ... master specific actions ... else ...
+   * worker specific actions ... fi
    */
   core.List<NodeInitializationAction> initializationActions;
   /**
    * [Optional] The Google Compute Engine config settings for the master
    * instance in a cluster.
    */
   InstanceGroupConfig masterConfig;
   /**
    * [Optional] The Google Compute Engine config settings for additional worker
    * instances in a cluster.
@@ skipping 53 matching lines @@
     if (softwareConfig != null) {
       _json["softwareConfig"] = (softwareConfig).toJson();
     }
     if (workerConfig != null) {
       _json["workerConfig"] = (workerConfig).toJson();
     }
     return _json;
   }
 }
 
+/**
+ * Contains cluster daemon metrics, such as HDFS and YARN stats. **Beta
+ * Feature**: This report is available for testing purposes only. It may be
+ * changed before final release.
+ */
+class ClusterMetrics {
+  /** The HDFS metrics. */
+  core.Map<core.String, core.String> hdfsMetrics;
+  /** The YARN metrics. */
+  core.Map<core.String, core.String> yarnMetrics;
+
+  ClusterMetrics();
+
+  ClusterMetrics.fromJson(core.Map _json) {
+    if (_json.containsKey("hdfsMetrics")) {
+      hdfsMetrics = _json["hdfsMetrics"];
+    }
+    if (_json.containsKey("yarnMetrics")) {
+      yarnMetrics = _json["yarnMetrics"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (hdfsMetrics != null) {
+      _json["hdfsMetrics"] = hdfsMetrics;
+    }
+    if (yarnMetrics != null) {
+      _json["yarnMetrics"] = yarnMetrics;
+    }
+    return _json;
+  }
+}
+
 /** Metadata describing the operation. */
 class ClusterOperationMetadata {
-  /** Name of the cluster for the operation. */
+  /** [Output-only] Name of the cluster for the operation. */
   core.String clusterName;
-  /** Cluster UUId for the operation. */
+  /** [Output-only] Cluster UUID for the operation. */
   core.String clusterUuid;
   /** [Output-only] Short description of operation. */
   core.String description;
+  /** [Output-only] labels associated with the operation */
+  core.Map<core.String, core.String> labels;
   /** [Output-only] The operation type. */
   core.String operationType;
   /** [Output-only] Current operation status. */
   ClusterOperationStatus status;
   /** [Output-only] The previous operation status. */
   core.List<ClusterOperationStatus> statusHistory;
 
   ClusterOperationMetadata();
 
   ClusterOperationMetadata.fromJson(core.Map _json) {
     if (_json.containsKey("clusterName")) {
       clusterName = _json["clusterName"];
     }
     if (_json.containsKey("clusterUuid")) {
       clusterUuid = _json["clusterUuid"];
     }
     if (_json.containsKey("description")) {
       description = _json["description"];
     }
+    if (_json.containsKey("labels")) {
+      labels = _json["labels"];
+    }
     if (_json.containsKey("operationType")) {
       operationType = _json["operationType"];
     }
     if (_json.containsKey("status")) {
       status = new ClusterOperationStatus.fromJson(_json["status"]);
     }
     if (_json.containsKey("statusHistory")) {
       statusHistory = _json["statusHistory"].map((value) => new ClusterOperationStatus.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (clusterName != null) {
       _json["clusterName"] = clusterName;
     }
     if (clusterUuid != null) {
       _json["clusterUuid"] = clusterUuid;
     }
     if (description != null) {
       _json["description"] = description;
     }
+    if (labels != null) {
+      _json["labels"] = labels;
+    }
     if (operationType != null) {
       _json["operationType"] = operationType;
     }
     if (status != null) {
       _json["status"] = (status).toJson();
     }
     if (statusHistory != null) {
       _json["statusHistory"] = statusHistory.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /** The status of the operation. */
 class ClusterOperationStatus {
-  /** A message containing any operation metadata details. */
+  /** [Output-only]A message containing any operation metadata details. */
   core.String details;
-  /** A message containing the detailed operation state. */
+  /** [Output-only] A message containing the detailed operation state. */
   core.String innerState;
   /**
-   * A message containing the operation state.
+   * [Output-only] A message containing the operation state.
    * Possible string values are:
    * - "UNKNOWN" : A UNKNOWN.
    * - "PENDING" : A PENDING.
    * - "RUNNING" : A RUNNING.
    * - "DONE" : A DONE.
    */
   core.String state;
-  /** The time this state was entered. */
+  /** [Output-only] The time this state was entered. */
   core.String stateStartTime;
 
   ClusterOperationStatus();
 
   ClusterOperationStatus.fromJson(core.Map _json) {
     if (_json.containsKey("details")) {
       details = _json["details"];
     }
     if (_json.containsKey("innerState")) {
       innerState = _json["innerState"];
@@ skipping 19 matching lines @@
     }
     if (stateStartTime != null) {
       _json["stateStartTime"] = stateStartTime;
     }
     return _json;
   }
 }
 
 /** The status of a cluster and its instances. */
 class ClusterStatus {
-  /** Optional details of cluster's state. */
+  /** [Output-only] Optional details of cluster's state. */
   core.String detail;
   /**
-   * The cluster's state.
+   * [Output-only] The cluster's state.
    * Possible string values are:
    * - "UNKNOWN" : A UNKNOWN.
    * - "CREATING" : A CREATING.
    * - "RUNNING" : A RUNNING.
    * - "ERROR" : A ERROR.
    * - "DELETING" : A DELETING.
    * - "UPDATING" : A UPDATING.
    */
   core.String state;
-  /** Time when this state was entered. */
+  /** [Output-only] Time when this state was entered. */
   core.String stateStartTime;
 
   ClusterStatus();
 
   ClusterStatus.fromJson(core.Map _json) {
     if (_json.containsKey("detail")) {
       detail = _json["detail"];
     }
     if (_json.containsKey("state")) {
       state = _json["state"];
@@ skipping 53 matching lines @@
 
   core.Map toJson() {
     var _json = new core.Map();
     return _json;
   }
 }
 
 /** The location of diagnostic output. */
 class DiagnoseClusterResults {
   /**
-   * [Output-only] The Google Cloud Storage URI of the diagnostic output. This
-   * is a plain text file with a summary of collected diagnostics.
+   * [Output-only] The Google Cloud Storage URI of the diagnostic output. The
+   * output report is a plain text file with a summary of collected diagnostics.
    */
   core.String outputUri;
 
   DiagnoseClusterResults();
 
   DiagnoseClusterResults.fromJson(core.Map _json) {
     if (_json.containsKey("outputUri")) {
       outputUri = _json["outputUri"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (outputUri != null) {
       _json["outputUri"] = outputUri;
     }
     return _json;
   }
 }
 
 /** Specifies the config of disk options for a group of VM instances. */
 class DiskConfig {
   /** [Optional] Size in GB of the boot disk (default is 500GB). */
   core.int bootDiskSizeGb;
   /**
    * [Optional] Number of attached SSDs, from 0 to 4 (default is 0). If SSDs are
-   * not attached, the boot disk is used to store runtime logs and HDFS data. If
+   * not attached, the boot disk is used to store runtime logs and
+   * [HDFS](https://hadoop.apache.org/docs/r1.2.1/hdfs_user_guide.html) data. If
    * one or more SSDs are attached, this runtime bulk data is spread across
    * them, and the boot disk contains only basic config and installed binaries.
    */
   core.int numLocalSsds;
 
   DiskConfig();
 
   DiskConfig.fromJson(core.Map _json) {
     if (_json.containsKey("bootDiskSizeGb")) {
       bootDiskSizeGb = _json["bootDiskSizeGb"];
@@ skipping 33 matching lines @@
     var _json = new core.Map();
     return _json;
   }
 }
 
 /**
  * Common config settings for resources of Google Compute Engine cluster
  * instances, applicable to all instances in the cluster.
  */
 class GceClusterConfig {
-  /** The Google Compute Engine metadata entries to add to all instances. */
+  /**
+   * [Optional] If true, all instances in the cluster will only have internal IP
+   * addresses. By default, clusters are not restricted to internal IP
+   * addresses, and will have ephemeral external IP addresses assigned to each
+   * instance. This `internal_ip_only` restriction can only be enabled for
+   * subnetwork enabled networks, and all off-cluster dependencies must be
+   * configured to be accessible without external IP addresses.
+   */
+  core.bool internalIpOnly;
+  /**
+   * The Google Compute Engine metadata entries to add to all instances (see
+   * [Project and instance
+   * metadata](https://cloud.google.com/compute/docs/storing-retrieving-metadata#project_and_instance_metadata)).
+   */
   core.Map<core.String, core.String> metadata;
   /**
-   * The Google Compute Engine network to be used for machine communications.
-   * Cannot be specified with subnetwork_uri. If neither network_uri nor
-   * subnetwork_uri is specified, the "default" network of the project is used,
-   * if it exists. Cannot be a "Custom Subnet Network" (see
-   * https://cloud.google.com/compute/docs/subnetworks for more information).
+   * [Optional] The Google Compute Engine network to be used for machine
+   * communications. Cannot be specified with subnetwork_uri. If neither
+   * `network_uri` nor `subnetwork_uri` is specified, the "default" network of
+   * the project is used, if it exists. Cannot be a "Custom Subnet Network" (see
+   * [Using Subnetworks](/compute/docs/subnetworks) for more information).
    * Example:
    * `https://www.googleapis.com/compute/v1/projects/[project_id]/regions/global/default`.
    */
   core.String networkUri;
   /**
-   * The URIs of service account scopes to be included in Google Compute Engine
-   * instances. The following base set of scopes is always included: *
-   * https://www.googleapis.com/auth/cloud.useraccounts.readonly *
+   * [Optional] The URIs of service account scopes to be included in Google
+   * Compute Engine instances. The following base set of scopes is always
+   * included: * https://www.googleapis.com/auth/cloud.useraccounts.readonly *
    * https://www.googleapis.com/auth/devstorage.read_write *
-   * https://www.googleapis.com/auth/logging.write If no scopes are specfied,
+   * https://www.googleapis.com/auth/logging.write If no scopes are specified,
    * the following defaults are also provided: *
    * https://www.googleapis.com/auth/bigquery *
    * https://www.googleapis.com/auth/bigtable.admin.table *
    * https://www.googleapis.com/auth/bigtable.data *
    * https://www.googleapis.com/auth/devstorage.full_control
    */
   core.List<core.String> serviceAccountScopes;
   /**
-   * The Google Compute Engine subnetwork to be used for machine communications.
-   * Cannot be specified with network_uri. Example:
+   * [Optional] The Google Compute Engine subnetwork to be used for machine
+   * communications. Cannot be specified with network_uri. Example:
    * `https://www.googleapis.com/compute/v1/projects/[project_id]/regions/us-east1/sub0`.
    */
   core.String subnetworkUri;
-  /** The Google Compute Engine tags to add to all instances. */
+  /**
+   * The Google Compute Engine tags to add to all instances (see [Tagging
+   * instances](/compute/docs/label-or-tag-resources#tags)).
+   */
   core.List<core.String> tags;
   /**
    * [Required] The zone where the Google Compute Engine cluster will be
    * located. Example:
    * `https://www.googleapis.com/compute/v1/projects/[project_id]/zones/[zone]`.
    */
   core.String zoneUri;
 
   GceClusterConfig();
 
   GceClusterConfig.fromJson(core.Map _json) {
+    if (_json.containsKey("internalIpOnly")) {
+      internalIpOnly = _json["internalIpOnly"];
+    }
     if (_json.containsKey("metadata")) {
       metadata = _json["metadata"];
     }
     if (_json.containsKey("networkUri")) {
       networkUri = _json["networkUri"];
     }
     if (_json.containsKey("serviceAccountScopes")) {
       serviceAccountScopes = _json["serviceAccountScopes"];
     }
     if (_json.containsKey("subnetworkUri")) {
       subnetworkUri = _json["subnetworkUri"];
     }
     if (_json.containsKey("tags")) {
       tags = _json["tags"];
     }
     if (_json.containsKey("zoneUri")) {
       zoneUri = _json["zoneUri"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
+    if (internalIpOnly != null) {
+      _json["internalIpOnly"] = internalIpOnly;
+    }
     if (metadata != null) {
       _json["metadata"] = metadata;
     }
     if (networkUri != null) {
       _json["networkUri"] = networkUri;
     }
     if (serviceAccountScopes != null) {
       _json["serviceAccountScopes"] = serviceAccountScopes;
     }
     if (subnetworkUri != null) {
       _json["subnetworkUri"] = subnetworkUri;
     }
     if (tags != null) {
       _json["tags"] = tags;
     }
     if (zoneUri != null) {
       _json["zoneUri"] = zoneUri;
     }
     return _json;
   }
 }
 
-/** A Cloud Dataproc job for running Hadoop MapReduce jobs on YARN. */
+/**
+ * A Cloud Dataproc job for running [Apache Hadoop
+ * MapReduce](https://hadoop.apache.org/docs/current/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html)
+ * jobs on [Apache Hadoop
+ * YARN](https://hadoop.apache.org/docs/r2.7.1/hadoop-yarn/hadoop-yarn-site/YARN.html).
+ */
 class HadoopJob {
   /**
    * [Optional] HCFS URIs of archives to be extracted in the working directory
    * of Hadoop drivers and tasks. Supported file types: .jar, .tar, .tar.gz,
    * .tgz, or .zip.
    */
   core.List<core.String> archiveUris;
   /**
    * [Optional] The arguments to pass to the driver. Do not include arguments,
    * such as `-libjars` or `-Dfoo=bar`, that can be set as job properties, since
@@ skipping 85 matching lines @@
     if (mainJarFileUri != null) {
       _json["mainJarFileUri"] = mainJarFileUri;
     }
     if (properties != null) {
       _json["properties"] = properties;
     }
     return _json;
   }
 }
 
-/** A Cloud Dataproc job for running Hive queries on YARN. */
+/**
+ * A Cloud Dataproc job for running [Apache Hive](https://hive.apache.org/)
+ * queries on YARN.
+ */
 class HiveJob {
   /**
    * [Optional] Whether to continue executing queries if a query fails. The
    * default value is `false`. Setting to `true` can be useful when executing
    * independent parallel queries.
    */
   core.bool continueOnFailure;
   /**
    * [Optional] HCFS URIs of jar files to add to the CLASSPATH of the Hive
    * server and Hadoop MapReduce (MR) tasks. Can contain Hive SerDes and UDFs.
@@ skipping 57 matching lines @@
       _json["queryList"] = (queryList).toJson();
     }
     if (scriptVariables != null) {
       _json["scriptVariables"] = scriptVariables;
     }
     return _json;
   }
 }
 
 /**
- * The config settings for Google Compute Engine resources in an instance group,
- * such as a master or worker group.
+ * [Optional] The config settings for Google Compute Engine resources in an
+ * instance group, such as a master or worker group.
  */
 class InstanceGroupConfig {
-  /** Disk option config settings. */
+  /** [Optional] Disk option config settings. */
   DiskConfig diskConfig;
   /**
    * [Output-only] The Google Compute Engine image resource used for cluster
    * instances. Inferred from `SoftwareConfig.image_version`.
    */
   core.String imageUri;
   /**
-   * The list of instance names. Cloud Dataproc derives the names from
-   * `cluster_name`, `num_instances`, and the instance group if not set by user
-   * (recommended practice is to let Cloud Dataproc derive the name).
+   * [Optional] The list of instance names. Cloud Dataproc derives the names
+   * from `cluster_name`, `num_instances`, and the instance group if not set by
+   * user (recommended practice is to let Cloud Dataproc derive the name).
    */
   core.List<core.String> instanceNames;
-  /** Specifies that this instance group contains Preemptible Instances. */
+  /**
+   * [Optional] Specifies that this instance group contains preemptible
+   * instances.
+   */
   core.bool isPreemptible;
   /**
-   * The Google Compute Engine machine type used for cluster instances. Example:
+   * [Required] The Google Compute Engine machine type used for cluster
+   * instances. Example:
    * `https://www.googleapis.com/compute/v1/projects/[project_id]/zones/us-east1-a/machineTypes/n1-standard-2`.
    */
   core.String machineTypeUri;
   /**
    * [Output-only] The config for Google Compute Engine Instance Group Manager
    * that manages this group. This is only used for preemptible instance groups.
    */
   ManagedGroupConfig managedGroupConfig;
   /**
-   * The number of VM instances in the instance group. For master instance
-   * groups, must be set to 1.
+   * [Required] The number of VM instances in the instance group. For master
+   * instance groups, must be set to 1.
    */
   core.int numInstances;
 
   InstanceGroupConfig();
 
   InstanceGroupConfig.fromJson(core.Map _json) {
     if (_json.containsKey("diskConfig")) {
       diskConfig = new DiskConfig.fromJson(_json["diskConfig"]);
     }
     if (_json.containsKey("imageUri")) {
@@ skipping 53 matching lines @@
   core.String driverControlFilesUri;
   /**
    * [Output-only] A URI pointing to the location of the stdout of the job's
    * driver program.
    */
   core.String driverOutputResourceUri;
   /** Job is a Hadoop job. */
   HadoopJob hadoopJob;
   /** Job is a Hive job. */
   HiveJob hiveJob;
+  /**
+   * [Optional] The labels to associate with this job. Label **keys** must
+   * contain 1 to 63 characters, and must conform to [RFC
+   * 1035](https://www.ietf.org/rfc/rfc1035.txt). Label **values** may be empty,
+   * but, if present, must contain 1 to 63 characters, and must conform to [RFC
+   * 1035](https://www.ietf.org/rfc/rfc1035.txt). No more than 32 labels can be
+   * associated with a job.
+   */
+  core.Map<core.String, core.String> labels;
   /** Job is a Pig job. */
   PigJob pigJob;
   /**
    * [Required] Job information, including how, when, and where to run the job.
    */
   JobPlacement placement;
   /** Job is a Pyspark job. */
   PySparkJob pysparkJob;
   /**
    * [Optional] The fully qualified reference to the job, which can be used to
    * obtain the equivalent REST path of the job resource. If this property is
    * not specified when a job is created, the server generates a job_id.
    */
   JobReference reference;
   /** Job is a Spark job. */
   SparkJob sparkJob;
   /** Job is a SparkSql job. */
   SparkSqlJob sparkSqlJob;
   /**
    * [Output-only] The job status. Additional application-specific status
    * information may be contained in the type_job and yarn_applications fields.
    */
   JobStatus status;
   /** [Output-only] The previous job status. */
   core.List<JobStatus> statusHistory;
+  /**
+   * [Output-only] The collection of YARN applications spun up by this job.
+   * **Beta** Feature: This report is available for testing purposes only. It
+   * may be changed before final release.
+   */
+  core.List<YarnApplication> yarnApplications;
 
   Job();
 
   Job.fromJson(core.Map _json) {
     if (_json.containsKey("driverControlFilesUri")) {
       driverControlFilesUri = _json["driverControlFilesUri"];
     }
     if (_json.containsKey("driverOutputResourceUri")) {
       driverOutputResourceUri = _json["driverOutputResourceUri"];
     }
     if (_json.containsKey("hadoopJob")) {
       hadoopJob = new HadoopJob.fromJson(_json["hadoopJob"]);
     }
     if (_json.containsKey("hiveJob")) {
       hiveJob = new HiveJob.fromJson(_json["hiveJob"]);
     }
+    if (_json.containsKey("labels")) {
+      labels = _json["labels"];
+    }
     if (_json.containsKey("pigJob")) {
       pigJob = new PigJob.fromJson(_json["pigJob"]);
     }
     if (_json.containsKey("placement")) {
       placement = new JobPlacement.fromJson(_json["placement"]);
     }
     if (_json.containsKey("pysparkJob")) {
       pysparkJob = new PySparkJob.fromJson(_json["pysparkJob"]);
     }
     if (_json.containsKey("reference")) {
       reference = new JobReference.fromJson(_json["reference"]);
     }
     if (_json.containsKey("sparkJob")) {
       sparkJob = new SparkJob.fromJson(_json["sparkJob"]);
     }
     if (_json.containsKey("sparkSqlJob")) {
       sparkSqlJob = new SparkSqlJob.fromJson(_json["sparkSqlJob"]);
     }
     if (_json.containsKey("status")) {
       status = new JobStatus.fromJson(_json["status"]);
     }
     if (_json.containsKey("statusHistory")) {
       statusHistory = _json["statusHistory"].map((value) => new JobStatus.fromJson(value)).toList();
     }
+    if (_json.containsKey("yarnApplications")) {
+      yarnApplications = _json["yarnApplications"].map((value) => new YarnApplication.fromJson(value)).toList();
+    }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (driverControlFilesUri != null) {
       _json["driverControlFilesUri"] = driverControlFilesUri;
     }
     if (driverOutputResourceUri != null) {
       _json["driverOutputResourceUri"] = driverOutputResourceUri;
     }
     if (hadoopJob != null) {
       _json["hadoopJob"] = (hadoopJob).toJson();
     }
     if (hiveJob != null) {
       _json["hiveJob"] = (hiveJob).toJson();
     }
+    if (labels != null) {
+      _json["labels"] = labels;
+    }
     if (pigJob != null) {
       _json["pigJob"] = (pigJob).toJson();
     }
     if (placement != null) {
       _json["placement"] = (placement).toJson();
     }
     if (pysparkJob != null) {
       _json["pysparkJob"] = (pysparkJob).toJson();
     }
     if (reference != null) {
       _json["reference"] = (reference).toJson();
     }
     if (sparkJob != null) {
       _json["sparkJob"] = (sparkJob).toJson();
     }
     if (sparkSqlJob != null) {
       _json["sparkSqlJob"] = (sparkSqlJob).toJson();
     }
     if (status != null) {
       _json["status"] = (status).toJson();
     }
     if (statusHistory != null) {
       _json["statusHistory"] = statusHistory.map((value) => (value).toJson()).toList();
     }
+    if (yarnApplications != null) {
+      _json["yarnApplications"] = yarnApplications.map((value) => (value).toJson()).toList();
+    }
     return _json;
   }
 }
 
 /** Cloud Dataproc job config. */
 class JobPlacement {
   /** [Required] The name of the cluster where the job will be submitted. */
   core.String clusterName;
   /**
    * [Output-only] A cluster UUID generated by the Cloud Dataproc service when
@@ skipping 20 matching lines @@
     if (clusterUuid != null) {
       _json["clusterUuid"] = clusterUuid;
     }
     return _json;
   }
 }
 
 /** Encapsulates the full scoping used to reference a job. */
 class JobReference {
   /**
-   * [Required] The job ID, which must be unique within the project. The job ID
+   * [Optional] The job ID, which must be unique within the project. The job ID
    * is generated by the server upon job submission or provided by the user as a
    * means to perform retries without creating duplicate jobs. The ID must
    * contain only letters (a-z, A-Z), numbers (0-9), underscores (_), or hyphens
    * (-). The maximum length is 512 characters.
    */
   core.String jobId;
   /**
    * [Required] The ID of the Google Cloud Platform project that the job belongs
    * to.
    */
@@ skipping 18 matching lines @@
     if (projectId != null) {
       _json["projectId"] = projectId;
     }
     return _json;
   }
 }
 
 /** Cloud Dataproc job status. */
 class JobStatus {
   /**
-   * [Optional] Job state details, such as an error description if the state is
-   * ERROR.
+   * [Output-only] Optional job state details, such as an error description if
+   * the state is ERROR.
    */
   core.String details;
   /**
-   * [Required] A state message specifying the overall job state.
+   * [Output-only] A state message specifying the overall job state.
    * Possible string values are:
    * - "STATE_UNSPECIFIED" : A STATE_UNSPECIFIED.
    * - "PENDING" : A PENDING.
    * - "SETUP_DONE" : A SETUP_DONE.
    * - "RUNNING" : A RUNNING.
    * - "CANCEL_PENDING" : A CANCEL_PENDING.
    * - "CANCEL_STARTED" : A CANCEL_STARTED.
    * - "CANCELLED" : A CANCELLED.
    * - "DONE" : A DONE.
    * - "ERROR" : A ERROR.
@@ skipping 29 matching lines @@
     }
     return _json;
   }
 }
 
 /** The list of all clusters in a project. */
 class ListClustersResponse {
   /** [Output-only] The clusters in the project. */
   core.List<Cluster> clusters;
   /**
-   * [Optional] This token is included in the response if there are more results
-   * to fetch. To fetch additional results, provide this value as the
+   * [Output-only] This token is included in the response if there are more
+   * results to fetch. To fetch additional results, provide this value as the
    * `page_token` in a subsequent ListClustersRequest.
    */
   core.String nextPageToken;
 
   ListClustersResponse();
 
   ListClustersResponse.fromJson(core.Map _json) {
     if (_json.containsKey("clusters")) {
       clusters = _json["clusters"].map((value) => new Cluster.fromJson(value)).toList();
     }
@@ skipping 179 matching lines @@
  * This resource represents a long-running operation that is the result of a
  * network API call.
  */
 class Operation {
   /**
    * If the value is `false`, it means the operation is still in progress. If
    * true, the operation is completed, and either `error` or `response` is
    * available.
    */
   core.bool done;
-  /** The error result of the operation in case of failure. */
+  /** The error result of the operation in case of failure or cancellation. */
   Status error;
   /**
    * Service-specific metadata associated with the operation. It typically
    * contains progress information and common metadata such as create time. Some
    * services might not provide such metadata. Any method that returns a
    * long-running operation should document the metadata type, if any.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
@@ skipping 222 matching lines @@
     if (state != null) {
       _json["state"] = state;
     }
     if (stateStartTime != null) {
       _json["stateStartTime"] = stateStartTime;
     }
     return _json;
   }
 }
 
-/** A Cloud Dataproc job for running Pig queries on YARN. */
+/**
+ * A Cloud Dataproc job for running [Apache Pig](https://pig.apache.org/)
+ * queries on YARN.
+ */
 class PigJob {
   /**
    * [Optional] Whether to continue executing queries if a query fails. The
    * default value is `false`. Setting to `true` can be useful when executing
    * independent parallel queries.
    */
   core.bool continueOnFailure;
   /**
    * [Optional] HCFS URIs of jar files to add to the CLASSPATH of the Pig Client
    * and Hadoop MapReduce (MR) tasks. Can contain Pig UDFs.
@@ skipping 64 matching lines @@
     if (queryList != null) {
       _json["queryList"] = (queryList).toJson();
     }
     if (scriptVariables != null) {
       _json["scriptVariables"] = scriptVariables;
     }
     return _json;
   }
 }
 
-/** A Cloud Dataproc job for running PySpark applications on YARN. */
+/**
+ * A Cloud Dataproc job for running [Apache
+ * PySpark](https://spark.apache.org/docs/0.9.0/python-programming-guide.html)
+ * applications on YARN.
+ */
 class PySparkJob {
   /**
    * [Optional] HCFS URIs of archives to be extracted in the working directory
    * of .jar, .tar, .tar.gz, .tgz, and .zip.
    */
   core.List<core.String> archiveUris;
   /**
    * [Optional] The arguments to pass to the driver. Do not include arguments,
    * such as `--conf`, that can be set as job properties, since a collision may
    * occur that causes an incorrect job submission.
@@ skipping 150 matching lines @@
     if (imageVersion != null) {
       _json["imageVersion"] = imageVersion;
     }
     if (properties != null) {
       _json["properties"] = properties;
     }
     return _json;
   }
 }
 
-/** A Cloud Dataproc job for running Spark applications on YARN. */
+/**
+ * A Cloud Dataproc job for running [Apache Spark](http://spark.apache.org/)
+ * applications on YARN.
+ */
 class SparkJob {
   /**
    * [Optional] HCFS URIs of archives to be extracted in the working directory
    * of Spark drivers and tasks. Supported file types: .jar, .tar, .tar.gz,
    * .tgz, and .zip.
    */
   core.List<core.String> archiveUris;
   /**
    * [Optional] The arguments to pass to the driver. Do not include arguments,
    * such as `--conf`, that can be set as job properties, since a collision may
@@ skipping 79 matching lines @@
     if (mainJarFileUri != null) {
       _json["mainJarFileUri"] = mainJarFileUri;
     }
     if (properties != null) {
       _json["properties"] = properties;
     }
     return _json;
   }
 }
 
-/** A Cloud Dataproc job for running Spark SQL queries. */
+/**
+ * A Cloud Dataproc job for running [Apache Spark
+ * SQL](http://spark.apache.org/sql/) queries.
+ */
 class SparkSqlJob {
   /** [Optional] HCFS URIs of jar files to be added to the Spark CLASSPATH. */
   core.List<core.String> jarFileUris;
   /** [Optional] The runtime log config for job execution. */
   LoggingConfig loggingConfig;
   /**
    * [Optional] A mapping of property names to values, used to configure Spark
    * SQL's SparkConf. Properties that conflict with values set by the Cloud
    * Dataproc API may be overwritten.
    */
@@ skipping 151 matching lines @@
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (job != null) {
       _json["job"] = (job).toJson();
     }
     return _json;
   }
 }
+
+/**
+ * A YARN application created by a job. Application information is a subset of
+ * org.apache.hadoop.yarn.proto.YarnProtos.ApplicationReportProto. **Beta
+ * Feature**: This report is available for testing purposes only. It may be
+ * changed before final release.
+ */
+class YarnApplication {
+  /** [Required] The application name. */
+  core.String name;
+  /** [Required] The numerical progress of the application, from 1 to 100. */
+  core.double progress;
+  /**
+   * [Required] The application state.
+   * Possible string values are:
+   * - "STATE_UNSPECIFIED" : A STATE_UNSPECIFIED.
+   * - "NEW" : A NEW.
+   * - "NEW_SAVING" : A NEW_SAVING.
+   * - "SUBMITTED" : A SUBMITTED.
+   * - "ACCEPTED" : A ACCEPTED.
+   * - "RUNNING" : A RUNNING.
+   * - "FINISHED" : A FINISHED.
+   * - "FAILED" : A FAILED.
+   * - "KILLED" : A KILLED.
+   */
+  core.String state;
+  /**
+   * [Optional] The HTTP URL of the ApplicationMaster, HistoryServer, or
+   * TimelineServer that provides application-specific information. The URL uses
+   * the internal hostname, and requires a proxy server for resolution and,
+   * possibly, access.
+   */
+  core.String trackingUrl;
+
+  YarnApplication();
+
+  YarnApplication.fromJson(core.Map _json) {
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+    if (_json.containsKey("progress")) {
+      progress = _json["progress"];
+    }
+    if (_json.containsKey("state")) {
+      state = _json["state"];
+    }
+    if (_json.containsKey("trackingUrl")) {
+      trackingUrl = _json["trackingUrl"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (name != null) {
+      _json["name"] = name;
+    }
+    if (progress != null) {
+      _json["progress"] = progress;
+    }
+    if (state != null) {
+      _json["state"] = state;
+    }
+    if (trackingUrl != null) {
+      _json["trackingUrl"] = trackingUrl;
+    }
+    return _json;
+  }
+}